CogWindow: CogWindows are not UObject anymore

CogWindows are now normal object because we want to be able to Ifdef them, and UObject cannot be ifdef. CogWindows were UObject mainly for saving their config. The configs have been moved in separated class, which are UObject.

Plugins/CogAbility/Source/CogAbility/Private/CogAbilityModule.cpp

@@ -1,7 +1,5 @@
 #include "CogAbilityModule.h"
 
-#include "CogAbilityReplicator.h"
-
 #define LOCTEXT_NAMESPACE "FCogAbilityModule"
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -12,8 +10,9 @@ void FCogAbilityModule::StartupModule()
 //--------------------------------------------------------------------------------------------------------------------------
 void FCogAbilityModule::ShutdownModule()
 {
+
 }
 
 #undef LOCTEXT_NAMESPACE
-	
+    
 IMPLEMENT_MODULE(FCogAbilityModule, CogAbility)

Plugins/CogAbility/Source/CogAbility/Private/CogAbilityWindow_Abilities.cpp

@@ -12,7 +12,17 @@
 #include "imgui_internal.h"
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::RenderHelp()
+void FCogAbilityWindow_Abilities::Initialize()
+{
+    Super::Initialize();
+
+    bHasMenu = true;
+
+    Asset = GetAsset<UCogAbilityDataAsset>();
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Abilities::RenderHelp()
 {
     ImGui::Text(
     "This window displays the gameplay abilities of the selected actor. "
@@ -23,15 +33,7 @@ void UCogAbilityWindow_Abilities::RenderHelp()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-UCogAbilityWindow_Abilities::UCogAbilityWindow_Abilities()
-{
-    bHasMenu = true;
-
-    Asset = FCogWindowHelper::GetFirstAssetByClass<UCogAbilityDataAsset>();
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::RenderTick(float DetlaTime)
+void FCogAbilityWindow_Abilities::RenderTick(float DetlaTime)
 {
     Super::RenderTick(DetlaTime);
 
@@ -39,7 +41,7 @@ void UCogAbilityWindow_Abilities::RenderTick(float DetlaTime)
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::RenderOpenAbilities()
+void FCogAbilityWindow_Abilities::RenderOpenAbilities()
 {
     AActor* Selection = GetSelection();
     if (Selection == nullptr)
@@ -84,7 +86,7 @@ void UCogAbilityWindow_Abilities::RenderOpenAbilities()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::RenderContent()
+void FCogAbilityWindow_Abilities::RenderContent()
 {
     Super::RenderContent();
 
@@ -106,7 +108,7 @@ void UCogAbilityWindow_Abilities::RenderContent()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::RenderAbiltiesMenu(AActor* Selection)
+void FCogAbilityWindow_Abilities::RenderAbiltiesMenu(AActor* Selection)
 {
     if (ImGui::BeginMenuBar())
     {
@@ -140,7 +142,7 @@ void UCogAbilityWindow_Abilities::RenderAbiltiesMenu(AActor* Selection)
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::RenderAbilitiesTable(UAbilitySystemComponent& AbilitySystemComponent)
+void FCogAbilityWindow_Abilities::RenderAbilitiesTable(UAbilitySystemComponent& AbilitySystemComponent)
 {
     TArray<FGameplayAbilitySpec>& Abilities = AbilitySystemComponent.GetActivatableAbilities();
 
@@ -253,7 +255,7 @@ void UCogAbilityWindow_Abilities::RenderAbilitiesTable(UAbilitySystemComponent&
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::RenderAbilityCooldown(const UAbilitySystemComponent& AbilitySystemComponent, UGameplayAbility& Ability)
+void FCogAbilityWindow_Abilities::RenderAbilityCooldown(const UAbilitySystemComponent& AbilitySystemComponent, UGameplayAbility& Ability)
 {
     FGameplayAbilitySpec* Spec = Ability.GetCurrentAbilitySpec();
 
@@ -275,7 +277,7 @@ void UCogAbilityWindow_Abilities::RenderAbilityCooldown(const UAbilitySystemComp
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::RenderAbilityContextMenu(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec, int Index)
+void FCogAbilityWindow_Abilities::RenderAbilityContextMenu(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec, int Index)
 {
     if (ImGui::BeginPopupContextItem())
     {
@@ -303,19 +305,19 @@ void UCogAbilityWindow_Abilities::RenderAbilityContextMenu(UAbilitySystemCompone
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::OpenAbility(const FGameplayAbilitySpecHandle& Handle)
+void FCogAbilityWindow_Abilities::OpenAbility(const FGameplayAbilitySpecHandle& Handle)
 {
     OpenedAbilities.AddUnique(Handle);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::CloseAbility(const FGameplayAbilitySpecHandle& Handle)
+void FCogAbilityWindow_Abilities::CloseAbility(const FGameplayAbilitySpecHandle& Handle)
 {
     OpenedAbilities.Remove(Handle);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-FString UCogAbilityWindow_Abilities::GetAbilityName(const UGameplayAbility* Ability)
+FString FCogAbilityWindow_Abilities::GetAbilityName(const UGameplayAbility* Ability)
 {
     if (Ability == nullptr)
     {
@@ -327,7 +329,7 @@ FString UCogAbilityWindow_Abilities::GetAbilityName(const UGameplayAbility* Abil
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::RenderAbilityInfo(const UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec)
+void FCogAbilityWindow_Abilities::RenderAbilityInfo(const UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec)
 {
     UGameplayAbility* Ability = Spec.GetPrimaryInstance();
     if (Ability == nullptr)
@@ -438,7 +440,7 @@ void UCogAbilityWindow_Abilities::RenderAbilityInfo(const UAbilitySystemComponen
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::GameTick(float DeltaTime)
+void FCogAbilityWindow_Abilities::GameTick(float DeltaTime)
 {
     if (AbilityHandleToActivate.IsValid())
     {
@@ -461,7 +463,7 @@ void UCogAbilityWindow_Abilities::GameTick(float DeltaTime)
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::ProcessAbilityActivation(const FGameplayAbilitySpecHandle& Handle)
+void FCogAbilityWindow_Abilities::ProcessAbilityActivation(const FGameplayAbilitySpecHandle& Handle)
 {
     AActor* Selection = GetSelection();
     if (Selection == nullptr)
@@ -492,14 +494,14 @@ void UCogAbilityWindow_Abilities::ProcessAbilityActivation(const FGameplayAbilit
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::ActivateAbility(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec)
+void FCogAbilityWindow_Abilities::ActivateAbility(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec)
 {
     Spec.InputPressed = true;
     AbilitySystemComponent.TryActivateAbility(Spec.Handle);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Abilities::DeactivateAbility(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec)
+void FCogAbilityWindow_Abilities::DeactivateAbility(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec)
 {
     Spec.InputPressed = false;
     AbilitySystemComponent.CancelAbilityHandle(Spec.Handle);

Plugins/CogAbility/Source/CogAbility/Private/CogAbilityWindow_Attributes.cpp

@@ -12,7 +12,18 @@
 #include "GameFramework/Character.h"
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Attributes::RenderHelp()
+void FCogAbilityWindow_Attributes::Initialize()
+{
+    Super::Initialize();
+
+    bHasMenu = true;
+
+    Asset = GetAsset<UCogAbilityDataAsset>();
+    Config = GetConfig<UCogAbilityConfig_Attributes>();
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Attributes::RenderHelp()
 {
     ImGui::Text(
         "This window displays the gameplay attributes of the selected actor. "
@@ -24,26 +35,15 @@ void UCogAbilityWindow_Attributes::RenderHelp()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-UCogAbilityWindow_Attributes::UCogAbilityWindow_Attributes()
-{
-    bHasMenu = true;
-
-    Asset = FCogWindowHelper::GetFirstAssetByClass<UCogAbilityDataAsset>();
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Attributes::ResetConfig()
+void FCogAbilityWindow_Attributes::ResetConfig()
 {
     Super::ResetConfig();
 
-    bSortByName = true;
-    bGroupByAttributeSet = false;
-    bGroupByCategory = false;
-    bShowOnlyModified = false;
+    Config->Reset();
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Attributes::RenderContent()
+void FCogAbilityWindow_Attributes::RenderContent()
 {
     Super::RenderContent();
 
@@ -57,10 +57,10 @@ void UCogAbilityWindow_Attributes::RenderContent()
     {
         if (ImGui::BeginMenu("Options"))
         {
-            ImGui::Checkbox("Sort by name", &bSortByName);
-            ImGui::Checkbox("Group by attribute set", &bGroupByAttributeSet);
-            ImGui::Checkbox("Group by category", &bGroupByCategory);
-            ImGui::Checkbox("Show Only Modified", &bShowOnlyModified);
+            ImGui::Checkbox("Sort by name", &Config->SortByName);
+            ImGui::Checkbox("Group by attribute set", &Config->GroupByAttributeSet);
+            ImGui::Checkbox("Group by category", &Config->GroupByCategory);
+            ImGui::Checkbox("Show Only Modified", &Config->ShowOnlyModified);
             ImGui::EndMenu();
         }
 
@@ -69,8 +69,8 @@ void UCogAbilityWindow_Attributes::RenderContent()
         ImGui::EndMenuBar();
     }
 
-    bool bGroupByAttributeSetValue = Filter.IsActive() == false && bShowOnlyModified == false && bGroupByAttributeSet;
-    bool bGroupByCategoryValue = Filter.IsActive() == false && bShowOnlyModified == false && bGroupByCategory;
+    bool bGroupByAttributeSetValue = Filter.IsActive() == false && Config->ShowOnlyModified == false && Config->GroupByAttributeSet;
+    bool bGroupByCategoryValue = Filter.IsActive() == false && Config->ShowOnlyModified == false && Config->GroupByCategory;
 
     if (ImGui::BeginTable("Attributes", 3, ImGuiTableFlags_SizingFixedFit 
                                          | ImGuiTableFlags_Resizable 
@@ -178,7 +178,7 @@ void UCogAbilityWindow_Attributes::RenderContent()
                         //------------------------------------------------------------------------------------------
                         // Sort attributes within a category by their name
                         //------------------------------------------------------------------------------------------
-                        if (bSortByName)
+                        if (Config->SortByName)
                         {
                             AttributesInCategory.Sort([](const FGameplayAttribute& Lhs, const FGameplayAttribute& Rhs)
                                 {
@@ -207,7 +207,7 @@ void UCogAbilityWindow_Attributes::RenderContent()
                             const float BaseValue = AbilitySystemComponent->GetNumericAttributeBase(Attribute);
                             const float CurrentValue = AbilitySystemComponent->GetNumericAttribute(Attribute);
 
-                            if (bShowOnlyModified && FMath::IsNearlyEqual(CurrentValue, BaseValue))
+                            if (Config->ShowOnlyModified && FMath::IsNearlyEqual(CurrentValue, BaseValue))
                             {
                                 continue;
                             }
@@ -293,7 +293,7 @@ void UCogAbilityWindow_Attributes::RenderContent()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Attributes::DrawAttributeInfo(const UAbilitySystemComponent& AbilitySystemComponent, const FGameplayAttribute& Attribute)
+void FCogAbilityWindow_Attributes::DrawAttributeInfo(const UAbilitySystemComponent& AbilitySystemComponent, const FGameplayAttribute& Attribute)
 {
     if (ImGui::BeginTable("Attribute", 2, ImGuiTableFlags_Borders))
     {
@@ -371,7 +371,7 @@ void UCogAbilityWindow_Attributes::DrawAttributeInfo(const UAbilitySystemCompone
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-ImVec4 UCogAbilityWindow_Attributes::GetAttributeColor(const UAbilitySystemComponent& AbilitySystemComponent, const FGameplayAttribute& Attribute) const
+ImVec4 FCogAbilityWindow_Attributes::GetAttributeColor(const UAbilitySystemComponent& AbilitySystemComponent, const FGameplayAttribute& Attribute) const
 {
     const float BaseValue = AbilitySystemComponent.GetNumericAttributeBase(Attribute);
     const float CurrentValue = AbilitySystemComponent.GetNumericAttribute(Attribute);
@@ -380,7 +380,7 @@ ImVec4 UCogAbilityWindow_Attributes::GetAttributeColor(const UAbilitySystemCompo
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-ImVec4 UCogAbilityWindow_Attributes::GetEffectModifierColor(const FModifierSpec& ModSpec, const FGameplayModifierInfo& ModInfo, float BaseValue) const
+ImVec4 FCogAbilityWindow_Attributes::GetEffectModifierColor(const FModifierSpec& ModSpec, const FGameplayModifierInfo& ModInfo, float BaseValue) const
 {
     const float ModValue = ModSpec.GetEvaluatedMagnitude();
     return FCogAbilityHelper::GetEffectModifierColor(Asset.Get(), ModSpec.GetEvaluatedMagnitude(), ModInfo.ModifierOp, BaseValue);

Plugins/CogAbility/Source/CogAbility/Private/CogAbilityWindow_Cheats.cpp

@@ -14,7 +14,18 @@
 #include "imgui_internal.h"
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Cheats::RenderHelp()
+void FCogAbilityWindow_Cheats::Initialize()
+{
+    Super::Initialize();
+
+    bHasMenu = true;
+
+    Asset = GetAsset<UCogAbilityDataAsset>();
+    Config = GetConfig<UCogAbilityConfig_Cheats>();
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Cheats::RenderHelp()
 {
     ImGui::Text(
         "This window can be used to apply cheats to the selected actor (by default). "
@@ -28,31 +39,15 @@ void UCogAbilityWindow_Cheats::RenderHelp()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-UCogAbilityWindow_Cheats::UCogAbilityWindow_Cheats()
-{
-    bHasMenu = true;
-
-    SetAsset(FCogWindowHelper::GetFirstAssetByClass<UCogAbilityDataAsset>());
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Cheats::ResetConfig()
+void FCogAbilityWindow_Cheats::ResetConfig()
 {
     Super::ResetConfig();
 
-    bReapplyCheatsBetweenPlays = true;
-    bReapplyCheatsBetweenLaunches = true;
+    Config->Reset();
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Cheats::SetAsset(const UCogAbilityDataAsset* Value) 
-{
-    Asset = Value;
-}
-
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Cheats::GameTick(float DeltaTime)
+void FCogAbilityWindow_Cheats::GameTick(float DeltaTime)
 {
     Super::GameTick(DeltaTime);
 
@@ -60,20 +55,25 @@ void UCogAbilityWindow_Cheats::GameTick(float DeltaTime)
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Cheats::TryReapplyCheats()
+void FCogAbilityWindow_Cheats::TryReapplyCheats()
 {
+    if (Config == nullptr)
+    {
+        return;
+    }
+    
     if (bHasReappliedCheats)
     {
         return;
     }
 
-    if (bReapplyCheatsBetweenPlays == false)
+    if (Config->bReapplyCheatsBetweenPlays == false)
     {
         return;
     }
 
     static int32 IsFirstLaunch = true;
-    if (IsFirstLaunch && bReapplyCheatsBetweenLaunches == false)
+    if (IsFirstLaunch && Config->bReapplyCheatsBetweenLaunches == false)
     {
         return;
     }
@@ -98,7 +98,7 @@ void UCogAbilityWindow_Cheats::TryReapplyCheats()
 
     TArray<AActor*> Targets { LocalPawn };
 
-    for (const FString& AppliedCheatName : AppliedCheats)
+    for (const FString& AppliedCheatName : Config->AppliedCheats)
     {
         if (const FCogAbilityCheat* Cheat = Asset->PersistentEffects.FindByPredicate(
             [AppliedCheatName](const FCogAbilityCheat& Cheat) { return Cheat.Name == AppliedCheatName; }))
@@ -111,14 +111,20 @@ void UCogAbilityWindow_Cheats::TryReapplyCheats()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Cheats::RenderContent()
+void FCogAbilityWindow_Cheats::RenderContent()
 {
     Super::RenderContent();
 
+    if (Config == nullptr)
+    {
+        ImGui::Text("Invalid Config");
+        return;
+    }
+
     AActor* SelectedActor = GetSelection();
     if (SelectedActor == nullptr)
     {
-        ImGui::Text("Invlid Selection");
+        ImGui::Text("Invalid Selection");
         return;
     }
 
@@ -132,15 +138,15 @@ void UCogAbilityWindow_Cheats::RenderContent()
     {
         if (ImGui::BeginMenu("Options"))
         {
-            ImGui::Checkbox("Reapply Cheats Between Plays", &bReapplyCheatsBetweenPlays);
+            ImGui::Checkbox("Reapply Cheats Between Plays", &Config->bReapplyCheatsBetweenPlays);
 
-            if (bReapplyCheatsBetweenPlays == false)
+            if (Config->bReapplyCheatsBetweenPlays == false)
             {
                 ImGui::BeginDisabled();
             }
-            ImGui::Checkbox("Reapply Cheats Between Launches", &bReapplyCheatsBetweenLaunches);
+            ImGui::Checkbox("Reapply Cheats Between Launches", &Config->bReapplyCheatsBetweenLaunches);
 
-            if (bReapplyCheatsBetweenPlays == false)
+            if (Config->bReapplyCheatsBetweenPlays == false)
             {
                 ImGui::EndDisabled();
             }
@@ -177,13 +183,13 @@ void UCogAbilityWindow_Cheats::RenderContent()
         //----------------------------------------------------------------
         if (bHasChanged && SelectedActor == ControlledActor)
         {
-            AppliedCheats.Empty();
+            Config->AppliedCheats.Empty();
 
             for (const FCogAbilityCheat& CheatEffect : Asset->PersistentEffects)
             {
                 if (ACogAbilityReplicator::IsCheatActive(SelectedActor, CheatEffect))
                 {
-                    AppliedCheats.Add(CheatEffect.Name);
+                    Config->AppliedCheats.Add(CheatEffect.Name);
                 }
             }
         }
@@ -203,7 +209,7 @@ void UCogAbilityWindow_Cheats::RenderContent()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-bool UCogAbilityWindow_Cheats::AddCheat(AActor* ControlledActor, AActor* SelectedActor, const FCogAbilityCheat& Cheat, bool IsPersistent)
+bool FCogAbilityWindow_Cheats::AddCheat(AActor* ControlledActor, AActor* SelectedActor, const FCogAbilityCheat& Cheat, bool IsPersistent)
 {
     if (Cheat.Effect == nullptr)
     {
@@ -268,7 +274,7 @@ bool UCogAbilityWindow_Cheats::AddCheat(AActor* ControlledActor, AActor* Selecte
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Cheats::RequestCheat(AActor* ControlledActor, AActor* SelectedActor, const FCogAbilityCheat& Cheat)
+void FCogAbilityWindow_Cheats::RequestCheat(AActor* ControlledActor, AActor* SelectedActor, const FCogAbilityCheat& Cheat)
 {
     const bool IsShiftDown = (ImGui::GetCurrentContext()->IO.KeyMods & ImGuiMod_Shift) != 0;
     const bool IsAltDown = (ImGui::GetCurrentContext()->IO.KeyMods & ImGuiMod_Alt) != 0;

Plugins/CogAbility/Source/CogAbility/Private/CogAbilityWindow_Effects.cpp

@@ -12,7 +12,17 @@
 #include "GameFramework/Character.h"
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Effects::RenderHelp()
+void FCogAbilityWindow_Effects::Initialize()
+{
+    Super::Initialize();
+
+    bHasMenu = false;
+
+    Asset = GetAsset<UCogAbilityDataAsset>();
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Effects::RenderHelp()
 {
     ImGui::Text(
         "This window displays the gameplay effects of the selected actor. "
@@ -21,15 +31,7 @@ void UCogAbilityWindow_Effects::RenderHelp()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-UCogAbilityWindow_Effects::UCogAbilityWindow_Effects()
-{
-    bHasMenu = false;
-
-    Asset = FCogWindowHelper::GetFirstAssetByClass<UCogAbilityDataAsset>();
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Effects::RenderContent()
+void FCogAbilityWindow_Effects::RenderContent()
 {
     Super::RenderContent();
 
@@ -37,7 +39,7 @@ void UCogAbilityWindow_Effects::RenderContent()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Effects::RenderEffectsTable()
+void FCogAbilityWindow_Effects::RenderEffectsTable()
 {
     UAbilitySystemComponent* AbilitySystemComponent = UAbilitySystemGlobals::GetAbilitySystemComponentFromActor(GetSelection(), true);
     if (AbilitySystemComponent == nullptr)
@@ -65,7 +67,7 @@ void UCogAbilityWindow_Effects::RenderEffectsTable()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Effects::RenderEffectRow(const UAbilitySystemComponent& AbilitySystemComponent, const FActiveGameplayEffectHandle& ActiveHandle, int32 Index, int32& Selected)
+void FCogAbilityWindow_Effects::RenderEffectRow(const UAbilitySystemComponent& AbilitySystemComponent, const FActiveGameplayEffectHandle& ActiveHandle, int32 Index, int32& Selected)
 {
     ImGui::PushID(Index);
 
@@ -146,7 +148,7 @@ void UCogAbilityWindow_Effects::RenderEffectRow(const UAbilitySystemComponent& A
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Effects::RenderEffectInfo(const UAbilitySystemComponent& AbilitySystemComponent, const FActiveGameplayEffect& ActiveEffect, const UGameplayEffect& Effect)
+void FCogAbilityWindow_Effects::RenderEffectInfo(const UAbilitySystemComponent& AbilitySystemComponent, const FActiveGameplayEffect& ActiveEffect, const UGameplayEffect& Effect)
 {
     if (ImGui::BeginTable("Effect", 2, ImGuiTableFlags_Borders))
     {
@@ -265,7 +267,7 @@ void UCogAbilityWindow_Effects::RenderEffectInfo(const UAbilitySystemComponent&
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Effects::RenderTagContainer(const FGameplayTagContainer& Container)
+void FCogAbilityWindow_Effects::RenderTagContainer(const FGameplayTagContainer& Container)
 {
     TArray<FGameplayTag> GameplayTags;
     Container.GetGameplayTagArray(GameplayTags);
@@ -276,14 +278,14 @@ void UCogAbilityWindow_Effects::RenderTagContainer(const FGameplayTagContainer&
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-FString UCogAbilityWindow_Effects::GetEffectName(const UGameplayEffect& Effect)
+FString FCogAbilityWindow_Effects::GetEffectName(const UGameplayEffect& Effect)
 {
     FString Str = FCogAbilityHelper::CleanupName(Effect.GetName());
     return Str;
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Effects::RenderRemainingTime(const UAbilitySystemComponent& AbilitySystemComponent, const FActiveGameplayEffect& ActiveEffect)
+void FCogAbilityWindow_Effects::RenderRemainingTime(const UAbilitySystemComponent& AbilitySystemComponent, const FActiveGameplayEffect& ActiveEffect)
 {
     const float StartTime = ActiveEffect.StartWorldTime;
     const float Duration = ActiveEffect.GetDuration();
@@ -301,7 +303,7 @@ void UCogAbilityWindow_Effects::RenderRemainingTime(const UAbilitySystemComponen
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Effects::RenderStacks(const FActiveGameplayEffect& ActiveEffect, const UGameplayEffect& Effect)
+void FCogAbilityWindow_Effects::RenderStacks(const FActiveGameplayEffect& ActiveEffect, const UGameplayEffect& Effect)
 {
     const int32 CurrentStackCount = ActiveEffect.Spec.StackCount;
     if (Effect.StackLimitCount <= 0)
@@ -319,7 +321,7 @@ void UCogAbilityWindow_Effects::RenderStacks(const FActiveGameplayEffect& Active
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Effects::RenderPrediction(const FActiveGameplayEffect& ActiveEffect, bool Short)
+void FCogAbilityWindow_Effects::RenderPrediction(const FActiveGameplayEffect& ActiveEffect, bool Short)
 {
     FString PredictionString;
     if (ActiveEffect.PredictionKey.IsValidKey())
@@ -342,13 +344,13 @@ void UCogAbilityWindow_Effects::RenderPrediction(const FActiveGameplayEffect& Ac
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-ImVec4 UCogAbilityWindow_Effects::GetEffectColor(const UGameplayEffect& Effect) const
+ImVec4 FCogAbilityWindow_Effects::GetEffectColor(const UGameplayEffect& Effect) const
 {
     return FCogAbilityHelper::GetEffectColor(Asset.Get(), Effect);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-ImVec4 UCogAbilityWindow_Effects::GetEffectModifierColor(const FModifierSpec& ModSpec, const FGameplayModifierInfo& ModInfo, float BaseValue) const
+ImVec4 FCogAbilityWindow_Effects::GetEffectModifierColor(const FModifierSpec& ModSpec, const FGameplayModifierInfo& ModInfo, float BaseValue) const
 {
     const float ModValue = ModSpec.GetEvaluatedMagnitude();
     return FCogAbilityHelper::GetEffectModifierColor(Asset.Get(), ModSpec.GetEvaluatedMagnitude(), ModInfo.ModifierOp, BaseValue);

Plugins/CogAbility/Source/CogAbility/Private/CogAbilityWindow_Pools.cpp

@@ -9,13 +9,15 @@
 #include "imgui_internal.h"
 
 //--------------------------------------------------------------------------------------------------------------------------
-UCogAbilityWindow_Pools::UCogAbilityWindow_Pools()
+void FCogAbilityWindow_Pools::Initialize()
 {
-    Asset = FCogWindowHelper::GetFirstAssetByClass<UCogAbilityDataAsset>();
+    Super::Initialize();
+
+    Asset = GetAsset<UCogAbilityDataAsset>();
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Pools::RenderHelp()
+void FCogAbilityWindow_Pools::RenderHelp()
 {
     ImGui::Text(
         "This window displays attributes of the selected actor as pools. "
@@ -25,7 +27,7 @@ void UCogAbilityWindow_Pools::RenderHelp()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Pools::RenderContent()
+void FCogAbilityWindow_Pools::RenderContent()
 {
     Super::RenderContent();
 
@@ -56,7 +58,7 @@ void UCogAbilityWindow_Pools::RenderContent()
 
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Pools::DrawPool(const UAbilitySystemComponent* AbilitySystemComponent, const FCogAbilityPool& Pool)
+void FCogAbilityWindow_Pools::DrawPool(const UAbilitySystemComponent* AbilitySystemComponent, const FCogAbilityPool& Pool)
 {
     if (AbilitySystemComponent->HasAttributeSetForAttribute(Pool.Max) == false)
     {

Plugins/CogAbility/Source/CogAbility/Private/CogAbilityWindow_Tags.cpp

@@ -6,19 +6,21 @@
 #include "CogWindowWidgets.h"
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Tags::RenderHelp()
+void FCogAbilityWindow_Tags::Initialize()
+{
+    Super::Initialize();
+
+    bHasMenu = false;
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogAbilityWindow_Tags::RenderHelp()
 {
     ImGui::Text("This window displays gameplay tags of the selected actor. ");
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-UCogAbilityWindow_Tags::UCogAbilityWindow_Tags()
-{
-    bHasMenu = false;
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Tags::RenderContent()
+void FCogAbilityWindow_Tags::RenderContent()
 {
     Super::RenderContent();
 
@@ -36,7 +38,7 @@ void UCogAbilityWindow_Tags::RenderContent()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Tags::DrawTag(const UAbilitySystemComponent& AbilitySystemComponent, const FGameplayTag& Tag)
+void FCogAbilityWindow_Tags::DrawTag(const UAbilitySystemComponent& AbilitySystemComponent, const FGameplayTag& Tag)
 {
     if (ImGui::BeginTable("Tag", 2, ImGuiTableFlags_Borders))
     {
@@ -94,7 +96,7 @@ void UCogAbilityWindow_Tags::DrawTag(const UAbilitySystemComponent& AbilitySyste
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Tags::DrawTagContainer(const FString& TagContainerName, const UAbilitySystemComponent& AbilitySystemComponent, FGameplayTagContainer& TagContainer)
+void FCogAbilityWindow_Tags::DrawTagContainer(const FString& TagContainerName, const UAbilitySystemComponent& AbilitySystemComponent, FGameplayTagContainer& TagContainer)
 {
     if (ImGui::BeginTable(TCHAR_TO_ANSI(*TagContainerName), 2, ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_Resizable | ImGuiTableFlags_NoBordersInBodyUntilResize | ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersOuterH | ImGuiTableFlags_BordersOuterV))
     {

Plugins/CogAbility/Source/CogAbility/Private/CogAbilityWindow_Tweaks.cpp

@@ -8,15 +8,17 @@
 #include "CogWindowWidgets.h"
 
 //--------------------------------------------------------------------------------------------------------------------------
-UCogAbilityWindow_Tweaks::UCogAbilityWindow_Tweaks()
+void FCogAbilityWindow_Tweaks::Initialize()
 {
+    Super::Initialize();
+
     bHasMenu = true;
 
-    Asset = FCogWindowHelper::GetFirstAssetByClass<UCogAbilityDataAsset>();
+    Asset = GetAsset<UCogAbilityDataAsset>();
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Tweaks::RenderHelp()
+void FCogAbilityWindow_Tweaks::RenderHelp()
 {
     ImGui::Text(
         "This window can be used to apply tweaks to all the loaded actors. "
@@ -27,7 +29,7 @@ void UCogAbilityWindow_Tweaks::RenderHelp()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Tweaks::RenderContent()
+void FCogAbilityWindow_Tweaks::RenderContent()
 {
     Super::RenderContent();
 
@@ -124,7 +126,7 @@ void UCogAbilityWindow_Tweaks::RenderContent()
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-void UCogAbilityWindow_Tweaks::DrawTweak(ACogAbilityReplicator* Replicator, int32 TweakIndex, int32 TweakCategoryIndex)
+void FCogAbilityWindow_Tweaks::DrawTweak(ACogAbilityReplicator* Replicator, int32 TweakIndex, int32 TweakCategoryIndex)
 {
     if (Asset->TweaksCategories.IsValidIndex(TweakCategoryIndex) == false)
     {

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityConfig.h

@@ -0,0 +1,47 @@
+#pragma once
+
+//#include "CoreMinimal.h"
+//#include "CogAbilityModule.h"
+//#include "CogAbilityConfig.generated.h"
+//
+//USTRUCT()
+//struct FCogAbilityAttributesConfig
+//{
+//    GENERATED_BODY()
+//
+//public:
+//
+//    UPROPERTY(Config)
+//    bool SortByName = true;
+//
+//    UPROPERTY(Config)
+//    bool GroupByAttributeSet = false;
+//
+//    UPROPERTY(Config)
+//    bool GroupByCategory = false;
+//
+//    UPROPERTY(Config)
+//    bool ShowOnlyModified = false;
+//
+//    void Reset()
+//    {
+//         SortByName = true;
+//         GroupByAttributeSet = false;
+//         GroupByCategory = false;
+//         ShowOnlyModified = false;
+//    }
+//};
+//
+//UCLASS(Config = Cog)
+//class COGABILITY_API UCogAbilityConfig : public UObject
+//{
+//    GENERATED_BODY()
+//
+//public:
+//
+//    static inline UCogAbilityConfig* Get() { return FCogAbilityModule::Config; }
+//
+//    UPROPERTY(Config)
+//    FCogAbilityAttributesConfig Attributes;
+//
+//};

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityModule.h

@@ -11,7 +11,5 @@ public:
 
     /** IModuleInterface implementation */
     virtual void StartupModule() override;
-
     virtual void ShutdownModule() override;
-
 };

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityWindow_Abilities.h

@@ -3,24 +3,22 @@
 #include "CoreMinimal.h"
 #include "CogWindow.h"
 #include "GameplayAbilitySpecHandle.h"
-#include "CogAbilityWindow_Abilities.generated.h"
 
 class UAbilitySystemComponent;
 class UGameplayAbility;
 class UCogAbilityDataAsset;
 struct FGameplayAbilitySpec;
 
-UCLASS()
-class COGABILITY_API UCogAbilityWindow_Abilities : public UCogWindow
+class COGABILITY_API FCogAbilityWindow_Abilities : public FCogWindow
 {
-    GENERATED_BODY()
+    typedef FCogWindow Super;
 
 public:
 
-    UCogAbilityWindow_Abilities();
+    virtual void Initialize() override;
 
 protected:
-
+    
     virtual void RenderHelp() override;
 
     virtual void RenderTick(float DetlaTime) override;
@@ -61,6 +59,5 @@ private:
 
     TArray<FGameplayAbilitySpecHandle> OpenedAbilities;
 
-    UPROPERTY()
     TObjectPtr<const UCogAbilityDataAsset> Asset = nullptr;
 };

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityWindow_Attributes.h

@@ -2,6 +2,7 @@
 
 #include "CoreMinimal.h"
 #include "CogWindow.h"
+#include "CogWindowConfig.h"
 #include "CogAbilityWindow_Attributes.generated.h"
 
 class UAbilitySystemComponent;
@@ -10,14 +11,14 @@ struct FGameplayAttribute;
 struct FModifierSpec;
 struct FGameplayModifierInfo;
 
-UCLASS(Config = Cog)
-class COGABILITY_API UCogAbilityWindow_Attributes : public UCogWindow
+//--------------------------------------------------------------------------------------------------------------------------
+class COGABILITY_API FCogAbilityWindow_Attributes : public FCogWindow
 {
-    GENERATED_BODY()
+    typedef FCogWindow Super;
 
 public:
 
-    UCogAbilityWindow_Attributes();
+    virtual void Initialize() override;
 
 protected:
 
@@ -35,20 +36,40 @@ protected:
 
 private:
 
-    UPROPERTY(Config)
-    bool bSortByName = true;
-
-    UPROPERTY(Config)
-    bool bGroupByAttributeSet = false;
-
-    UPROPERTY(Config)
-    bool bGroupByCategory = false;
-
-    UPROPERTY(Config)
-    bool bShowOnlyModified = false;
-
     ImGuiTextFilter Filter;
 
-    UPROPERTY()
     TObjectPtr<const UCogAbilityDataAsset> Asset = nullptr;
+    
+    TObjectPtr<UCogAbilityConfig_Attributes> Config = nullptr;
 };
+
+//--------------------------------------------------------------------------------------------------------------------------
+UCLASS(Config = Cog)
+class UCogAbilityConfig_Attributes : public UCogWindowConfig
+{
+    GENERATED_BODY()
+
+public:
+
+    UPROPERTY(Config)
+    bool SortByName = true;
+
+    UPROPERTY(Config)
+    bool GroupByAttributeSet = false;
+
+    UPROPERTY(Config)
+    bool GroupByCategory = false;
+
+    UPROPERTY(Config)
+    bool ShowOnlyModified = false;
+
+    virtual void Reset() override
+    {
+        Super::Reset();
+
+        SortByName = true;
+        GroupByAttributeSet = false;
+        GroupByCategory = false;
+        ShowOnlyModified = false;
+    }
+};

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityWindow_Cheats.h

@@ -2,24 +2,21 @@
 
 #include "CoreMinimal.h"
 #include "CogWindow.h"
+#include "CogWindowConfig.h"
 #include "CogAbilityWindow_Cheats.generated.h"
 
 class AActor;
 class UCogAbilityDataAsset;
 struct FCogAbilityCheat;
 
-UCLASS(Config = Cog)
-class COGABILITY_API UCogAbilityWindow_Cheats : public UCogWindow
+//--------------------------------------------------------------------------------------------------------------------------
+class COGABILITY_API FCogAbilityWindow_Cheats : public FCogWindow
 {
-    GENERATED_BODY()
+    typedef FCogWindow Super;
 
 public:
 
-    UCogAbilityWindow_Cheats();
-
-    const UCogAbilityDataAsset* GetAsset() const { return Asset.Get(); }
-
-    void SetAsset(const UCogAbilityDataAsset* Value);
+    virtual void Initialize() override;
 
 protected:
 
@@ -37,6 +34,21 @@ protected:
 
     virtual void RequestCheat(AActor* ControlledActor, AActor* TargetActor, const FCogAbilityCheat& CheatEffect);
 
+    TObjectPtr<const UCogAbilityDataAsset> Asset = nullptr;
+
+    TObjectPtr<UCogAbilityConfig_Cheats> Config = nullptr;
+
+    bool bHasReappliedCheats = false;
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+UCLASS(Config = Cog)
+class UCogAbilityConfig_Cheats : public UCogWindowConfig
+{
+    GENERATED_BODY()
+
+public:
+
     UPROPERTY(Config)
     bool bReapplyCheatsBetweenPlays = true;
 
@@ -46,8 +58,11 @@ protected:
     UPROPERTY(Config)
     TArray<FString> AppliedCheats;
 
-    UPROPERTY()
-    TObjectPtr<const UCogAbilityDataAsset> Asset = nullptr;
+    virtual void Reset() override
+    {
+        Super::Reset();
 
-    bool bHasReappliedCheats = false;
+        bReapplyCheatsBetweenPlays = true;
+        bReapplyCheatsBetweenLaunches = true;
+    }
 };

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityWindow_Effects.h

@@ -4,7 +4,6 @@
 #include "GameplayTagContainer.h"
 #include "CogWindow.h"
 #include "imgui.h"
-#include "CogAbilityWindow_Effects.generated.h"
 
 class UAbilitySystemComponent;
 class UCogAbilityDataAsset;
@@ -15,14 +14,14 @@ struct FGameplayModifierInfo;
 struct FModifierSpec;
 namespace EGameplayModOp { enum Type; };
 
-UCLASS()
-class COGABILITY_API UCogAbilityWindow_Effects : public UCogWindow
+//--------------------------------------------------------------------------------------------------------------------------
+class COGABILITY_API FCogAbilityWindow_Effects : public FCogWindow
 {
-    GENERATED_BODY()
+    typedef FCogWindow Super;
 
 public:
 
-    UCogAbilityWindow_Effects();
+    virtual void Initialize() override;
 
 protected:
 
@@ -50,6 +49,5 @@ protected:
 
     ImVec4 GetEffectModifierColor(const FModifierSpec& ModSpec, const FGameplayModifierInfo& ModInfo, float BaseValue) const;
 
-    UPROPERTY()
     TObjectPtr<const UCogAbilityDataAsset> Asset = nullptr;
 };

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityWindow_Pools.h

@@ -3,20 +3,19 @@
 #include "CoreMinimal.h"
 #include "GameplayTagContainer.h"
 #include "CogWindow.h"
-#include "CogAbilityWindow_Pools.generated.h"
 
 class UCogAbilityDataAsset;
 class UAbilitySystemComponent;
 struct FCogAbilityPool;
 
-UCLASS()
-class COGABILITY_API UCogAbilityWindow_Pools : public UCogWindow
+//--------------------------------------------------------------------------------------------------------------------------
+class COGABILITY_API FCogAbilityWindow_Pools : public FCogWindow
 {
-    GENERATED_BODY()
+    typedef FCogWindow Super;
 
 public:
-    
-    UCogAbilityWindow_Pools();
+
+    virtual void Initialize() override;
 
 protected:
 
@@ -26,6 +25,5 @@ protected:
 
     virtual void DrawPool(const UAbilitySystemComponent* AbilitySystemComponent, const FCogAbilityPool& Pool);
 
-    UPROPERTY()
     TObjectPtr<const UCogAbilityDataAsset> Asset = nullptr;
 };

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityWindow_Tags.h

@@ -2,20 +2,19 @@
 
 #include "CoreMinimal.h"
 #include "CogWindow.h"
-#include "CogAbilityWindow_Tags.generated.h"
 
 class UAbilitySystemComponent;
 struct FGameplayTagContainer;
 struct FGameplayTag;
 
-UCLASS()
-class COGABILITY_API UCogAbilityWindow_Tags : public UCogWindow
+//--------------------------------------------------------------------------------------------------------------------------
+class COGABILITY_API FCogAbilityWindow_Tags : public FCogWindow
 {
-    GENERATED_BODY()
+    typedef FCogWindow Super;
 
 public:
 
-    UCogAbilityWindow_Tags();
+    virtual void Initialize() override;
 
 protected:
 

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityWindow_Tweaks.h

@@ -2,19 +2,18 @@
 
 #include "CoreMinimal.h"
 #include "CogWindow.h"
-#include "CogAbilityWindow_Tweaks.generated.h"
 
 class ACogAbilityReplicator;
 class UCogAbilityDataAsset;
 
-UCLASS()
-class COGABILITY_API UCogAbilityWindow_Tweaks : public UCogWindow
+//--------------------------------------------------------------------------------------------------------------------------
+class COGABILITY_API FCogAbilityWindow_Tweaks : public FCogWindow
 {
-    GENERATED_BODY()
+    typedef FCogWindow Super;
 
 public:
 
-    UCogAbilityWindow_Tweaks();
+    virtual void Initialize() override;
 
 protected:
 
@@ -26,6 +25,5 @@ protected:
 
 private:
 
-    UPROPERTY()
     TObjectPtr<const UCogAbilityDataAsset> Asset = nullptr;
 };