First Submit

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityDamageActorInterface.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "CogAbilityDamageActorInterface.generated.h"
+
+//--------------------------------------------------------------------------------------------------------------------------
+USTRUCT()
+struct COGABILITY_API FCogAbilityDamageParams
+{
+    GENERATED_BODY()
+
+    TObjectPtr<AActor> DamageDealer;
+    TObjectPtr<AActor> DamageReceiver;
+    float ReceivedDamage = 0;
+    float IncomingDamage = 0;
+    bool IsCritical = false;
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+DECLARE_MULTICAST_DELEGATE_OneParam(FCogAbilityOnDamageEvent, const FCogAbilityDamageParams&);
+
+//--------------------------------------------------------------------------------------------------------------------------
+UINTERFACE(MinimalAPI, Blueprintable)
+class UCogAbilityDamageActorInterface : public UInterface
+{
+    GENERATED_BODY()
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+class ICogAbilityDamageActorInterface
+{
+    GENERATED_BODY()
+
+public:
+    virtual FCogAbilityOnDamageEvent& OnDamageEvent()  = 0;
+};

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityDataAsset_Abilities.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Engine/DataAsset.h"
+#include "CogAbilityDataAsset_Abilities.generated.h"
+
+class UGameplayAbility;
+
+//--------------------------------------------------------------------------------------------------------------------------
+UCLASS(Blueprintable)
+class COGABILITY_API UCogAbilityDataAsset_Abilities : public UPrimaryDataAsset
+{
+    GENERATED_BODY()
+
+public:
+    
+    UCogAbilityDataAsset_Abilities() {}
+
+    UPROPERTY(EditAnywhere)
+    TArray<TSubclassOf<UGameplayAbility>> Abilities;
+};

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityDataAsset_Cheats.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Engine/DataAsset.h"
+#include "GameplayEffect.h"
+#include "CogAbilityDataAsset_Cheats.generated.h"
+
+//--------------------------------------------------------------------------------------------------------------------------
+USTRUCT()
+struct COGABILITY_API FCogAbilityCheat
+{
+    GENERATED_BODY()
+
+    UPROPERTY(EditAnywhere)
+    FString Name;
+
+    UPROPERTY(EditAnywhere)
+    TSubclassOf<UGameplayEffect> Effect;
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+UCLASS(Blueprintable)
+class COGABILITY_API UCogAbilityDataAsset_Cheats : public UPrimaryDataAsset
+{
+    GENERATED_BODY()
+
+public:
+    
+    UCogAbilityDataAsset_Cheats() {}
+
+    UPROPERTY(EditAnywhere)
+    FGameplayTag NegativeEffectTag;
+    
+    UPROPERTY(EditAnywhere)
+    FGameplayTag PositiveEffectTag;
+
+    UPROPERTY(EditAnywhere)
+    FLinearColor NeutralEffectColor = FLinearColor(0.5f, 0.5f, 0.5f, 1.0f);
+
+    UPROPERTY(EditAnywhere)
+    FLinearColor NegativeEffectColor = FLinearColor(1.0f, 0.5f, 0.5f, 1.0f);
+
+    UPROPERTY(EditAnywhere)
+    FLinearColor PositiveEffectColor = FLinearColor(0.0f, 1.0f, 0.5f, 1.0f);
+
+    UPROPERTY(EditAnywhere, meta = (TitleProperty = "Name"))
+    TArray<FCogAbilityCheat> PersistentEffects;
+
+    UPROPERTY(EditAnywhere, meta = (TitleProperty = "Name"))
+    TArray<FCogAbilityCheat> InstantEffects;
+};

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityDataAsset_Pools.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Engine/DataAsset.h"
+#include "CogAbilityDataAsset_Pools.generated.h"
+
+//--------------------------------------------------------------------------------------------------------------------------
+USTRUCT()
+struct COGABILITY_API FCogAbilityPool
+{
+    GENERATED_BODY()
+
+    UPROPERTY(EditAnywhere)
+    FString Name;
+
+    UPROPERTY(EditAnywhere)
+    FGameplayAttribute Value;
+
+    UPROPERTY(EditAnywhere)
+    FGameplayAttribute Min;
+
+    UPROPERTY(EditAnywhere)
+    FGameplayAttribute Max;
+
+    UPROPERTY(EditAnywhere)
+    FGameplayAttribute Regen;
+
+    UPROPERTY(EditAnywhere)
+    FLinearColor Color = FLinearColor(0.5f, 0.5f, 0.5f, 1.0f);
+
+    UPROPERTY(EditAnywhere)
+    FLinearColor BackColor = FLinearColor(0.15, 0.15, 0.15, 1.0f);
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+UCLASS(Blueprintable)
+class COGABILITY_API UCogAbilityDataAsset_Pools : public UPrimaryDataAsset
+{
+    GENERATED_BODY()
+
+public:
+    
+    UCogAbilityDataAsset_Pools() {}
+
+    UPROPERTY(EditAnywhere, meta = (TitleProperty = "Name"))
+    TArray<FCogAbilityPool> Pools;
+};

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityDataAsset_Tweaks.h

@@ -0,0 +1,108 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Engine/DataAsset.h"
+#include "CogAbilityDataAsset_Tweaks.generated.h"
+
+class UGameplayEffect;
+
+//--------------------------------------------------------------------------------------------------------------------------
+USTRUCT()
+struct FCogAbilityTweak
+{
+    GENERATED_BODY()
+
+    UPROPERTY(EditAnywhere)
+    FName Name;
+
+    UPROPERTY(EditAnywhere)
+    TSubclassOf<UGameplayEffect> Effect;
+
+    UPROPERTY(EditAnywhere)
+    float Multiplier = 0.01f;
+
+    UPROPERTY(EditAnywhere)
+    float AddPostMultiplier = 1.0f;
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+USTRUCT()
+struct FCogAbilityTweakCategory
+{
+    GENERATED_BODY()
+
+    UPROPERTY(EditAnywhere)
+    FString Name;
+
+    UPROPERTY(EditAnywhere)
+    FGameplayTag Id;
+
+    UPROPERTY(EditAnywhere)
+    TSubclassOf<AActor> ActorClass;
+
+    UPROPERTY(EditAnywhere)
+    FGameplayTagContainer RequiredTags;
+
+    UPROPERTY(EditAnywhere)
+    FGameplayTagContainer IgnoredTags;
+
+    UPROPERTY(EditAnywhere)
+    FLinearColor Color = FLinearColor::White;
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+USTRUCT()
+struct FCogAbilityTweakProfileValue
+{
+    GENERATED_BODY()
+
+    UPROPERTY(EditAnywhere)
+    TSubclassOf<UGameplayEffect> Effect;
+
+    UPROPERTY(EditAnywhere)
+    FGameplayTag CategoryId;
+
+    UPROPERTY(EditAnywhere)
+    float Value = 0.0f;
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+USTRUCT()
+struct FCogAbilityTweakProfile
+{
+    GENERATED_BODY()
+
+    UPROPERTY(EditAnywhere)
+    FName Name;
+
+    UPROPERTY(EditAnywhere)
+    TArray<FCogAbilityTweakProfileValue> Tweaks;
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+UCLASS(Blueprintable)
+class COGABILITY_API UCogAbilityDataAsset_Tweaks : public UPrimaryDataAsset
+{
+    GENERATED_BODY()
+
+public:
+    UCogAbilityDataAsset_Tweaks() {}
+
+    UPROPERTY(EditAnywhere)
+    float TweakMinValue = -100.0f;
+
+    UPROPERTY(EditAnywhere)
+    float TweakMaxValue = 200.0f;
+
+    UPROPERTY(EditAnywhere)
+    FGameplayTag SetByCallerMagnitudeTag;
+
+    UPROPERTY(EditAnywhere, meta = (TitleProperty = "Name"))
+    TArray<FCogAbilityTweak> Tweaks;
+
+    UPROPERTY(EditAnywhere, meta = (TitleProperty = "Name"))
+    TArray<FCogAbilityTweakCategory> TweaksCategories;
+
+    UPROPERTY(EditAnywhere, meta = (TitleProperty = "Name"))
+    TArray<FCogAbilityTweakProfile>  TweakProfiles;
+};

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityHelper.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "CoreMinimal.h"
+
+class COGABILITY_API FCogAbilityHelper
+{
+public:
+
+    static FString CleanupName(FString Str);
+};

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

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Modules/ModuleManager.h"
+
+class ACogAbilityReplicator;
+class APlayerController;
+
+class COGABILITY_API FCogAbilityModule : public IModuleInterface
+{
+public:
+
+    static inline FCogAbilityModule& Get()
+    {
+        return FModuleManager::LoadModuleChecked<FCogAbilityModule>("CogAbility");
+    }
+
+    /** IModuleInterface implementation */
+    virtual void StartupModule() override;
+    virtual void ShutdownModule() override;
+
+    ACogAbilityReplicator* GetLocalReplicator();
+    void SetLocalReplicator(ACogAbilityReplicator* Value);
+    ACogAbilityReplicator* GetRemoteReplicator(const APlayerController* PlayerController);
+    void AddRemoteReplicator(ACogAbilityReplicator* Value);
+
+private:
+    TObjectPtr<ACogAbilityReplicator> LocalReplicator;
+    TArray<TObjectPtr<ACogAbilityReplicator>> RemoteReplicators;
+};

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityReplicator.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "CogAbilityReplicator.generated.h"
+
+class AActor;
+class UAbilitySystemComponent;
+class UCogAbilityDataAsset_Tweaks;
+struct FCogAbilityCheat;
+struct FCogAbilityTweak;
+struct FGameplayTag;
+
+UCLASS(NotBlueprintable, NotBlueprintType, notplaceable, noteditinlinenew, hidedropdown, Transient)
+class COGABILITY_API ACogAbilityReplicator : public AActor
+{
+    GENERATED_UCLASS_BODY()
+
+public:
+
+    static void Create(APlayerController* Controller);
+
+    virtual void BeginPlay() override;
+
+    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);
+
+    void ResetAllTweaks();
+
+    void SetTweakValue(const UCogAbilityDataAsset_Tweaks* TweaksAsset, int32 TweakIndex, int32 CategoryIndex, float Value);
+
+    void SetTweakProfile(const UCogAbilityDataAsset_Tweaks* TweaksAsset, int32 ProfileIndex);
+
+    int32 GetTweakProfileIndex() const { return TweakProfileIndex; }
+
+    float GetTweakCurrentValue(const UCogAbilityDataAsset_Tweaks* TweaksAsset, int32 TweakIndex, int32 CategoryIndex);
+
+    float* GetTweakCurrentValuePtr(const UCogAbilityDataAsset_Tweaks* TweaksAsset, int32 TweakIndex, int32 CategoryIndex);
+
+private:
+
+    UFUNCTION(Reliable, Server)
+    void Server_ApplyCheat(const AActor* CheatInstigator, const TArray<AActor*>& TargetActors, const FCogAbilityCheat& Cheat) const;
+
+    UFUNCTION(Reliable, Server)
+    void Server_GiveAbility(AActor* TargetActor, TSubclassOf<UGameplayAbility> AbilityClass) const;
+
+    UFUNCTION(Reliable, Server)
+    void Server_ResetAllTweaks();
+
+    UFUNCTION(Reliable, Server)
+    void Server_SetTweakValue(const UCogAbilityDataAsset_Tweaks* TweaksAsset, int32 TweakIndex, int32 TweakCategoryIndex, float Value);
+
+    UFUNCTION(Reliable, Server)
+    void Server_SetTweakProfile(const UCogAbilityDataAsset_Tweaks* TweaksAsset, int32 ProfileIndex);
+
+    void SetTweakCurrentValue(const UCogAbilityDataAsset_Tweaks* TweaksAsset, int32 TweakIndex, int32 CategoryIndex, float Value);
+    void ApplyTweakOnActor(AActor* Actor, const FCogAbilityTweak& Tweak, float Value, const FGameplayTag& SetByCallerMagnitudeTag);
+    void ApplyAllTweaksOnActor(const UCogAbilityDataAsset_Tweaks* TweaksAsset, int32 TweakCategoryIndex, AActor* Actor);
+    void GetActorsFromTweakCategory(const UCogAbilityDataAsset_Tweaks* TweaksAsset, int32 CategoryIndex, TArray<AActor*>& Actors);
+
+    TObjectPtr<APlayerController> OwnerPlayerController;
+
+    UPROPERTY(Replicated)
+    int32 TweakProfileIndex = INDEX_NONE;
+
+    UPROPERTY(Replicated)
+    TArray<float> TweakCurrentValues;
+};

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

@@ -0,0 +1,57 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "CogWindow.h"
+#include "CogAbilityWindow_Abilities.generated.h"
+
+class UGameplayAbility;
+class UCogAbilityDataAsset_Abilities;
+struct FGameplayAbilitySpec;
+
+UCLASS()
+class COGABILITY_API UCogAbilityWindow_Abilities : public UCogWindow
+{
+    GENERATED_BODY()
+
+public:
+    
+    TWeakObjectPtr<UCogAbilityDataAsset_Abilities> AbilitiesAsset;
+
+protected:
+
+    virtual void PreRender(ImGuiWindowFlags& WindowFlags) override;
+
+    virtual void RenderTick(float DetlaTime) override;
+
+    virtual void RenderContent() override;
+
+    virtual void GameTick(float DeltaTime) override;
+
+    virtual void RenderAbiltiesMenu(AActor* Selection);
+
+    virtual FString GetAbilityName(const UGameplayAbility* Ability);
+
+    virtual void RenderAbilitiesTable(UAbilitySystemComponent& AbilitySystemComponent);
+
+    virtual void RenderAbilityContextMenu(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec, int Index);
+
+    virtual void RenderOpenAbilities();
+
+    virtual void RenderAbilityInfo(FGameplayAbilitySpec& Spec);
+
+    virtual void ProcessAbilityActivation(FGameplayAbilitySpecHandle Handle);
+
+    virtual void ActivateAbility(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec);
+
+    virtual void DeactivateAbility(UAbilitySystemComponent& AbilitySystemComponent, FGameplayAbilitySpec& Spec);
+
+    virtual void OpenAbility(FGameplayAbilitySpecHandle Handle);
+
+    virtual void CloseAbility(FGameplayAbilitySpecHandle Handle);
+
+private:
+
+    FGameplayAbilitySpecHandle AbilityHandleToActivate;
+
+    TArray<FGameplayAbilitySpecHandle> OpenedAbilities;
+};

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

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "CogWindow.h"
+#include "CogAbilityWindow_Attributes.generated.h"
+
+UCLASS(Config = Cog)
+class COGABILITY_API UCogAbilityWindow_Attributes : public UCogWindow
+{
+    GENERATED_BODY()
+
+public:
+    UCogAbilityWindow_Attributes();
+
+    virtual void PreRender(ImGuiWindowFlags& WindowFlags) override;
+    virtual void RenderContent() override;
+
+    UPROPERTY(Config)
+    bool bSortByNameSetting = true;
+
+    UPROPERTY(Config)
+    bool bGroupByAttributeSetSetting = false;
+
+    UPROPERTY(Config)
+    bool bGroupByCategorySetting = false;
+
+    UPROPERTY(Config)
+    bool bShowOnlyModified = false;
+
+    ImGuiTextFilter Filter;
+};

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

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "CogWindow.h"
+#include "CogAbilityWindow_Cheats.generated.h"
+
+class AActor;
+class UCogAbilityDataAsset_Cheats;
+struct FCogAbilityCheat;
+
+UCLASS(Config = Cog)
+class COGABILITY_API UCogAbilityWindow_Cheats : public UCogWindow
+{
+    GENERATED_BODY()
+
+public:
+    UCogAbilityWindow_Cheats();
+    virtual void RenderContent() override;
+
+    TWeakObjectPtr<UCogAbilityDataAsset_Cheats> CheatsAsset;
+
+private:
+    
+    void AddCheat(AActor* InstigatorActor, AActor* TargetActor, const FCogAbilityCheat& CheatEffect, bool IsPersistent);
+
+    void RequestCheat(AActor* InstigatorActor, AActor* TargetActor, const FCogAbilityCheat& CheatEffect);
+
+    UPROPERTY(Config)
+    TArray<FString> AppliedCheats;
+};

Plugins/CogAbility/Source/CogAbility/Public/CogAbilityWindow_Damages.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "CogWindow.h"
+#include "CogAbilityWindow_Damages.generated.h"
+
+struct FCogAbilityDamageParams;
+
+//--------------------------------------------------------------------------------------------------------------------------
+class FCogDamageInstance
+{
+public:
+    void Restart();
+    void AddDamage(const float Damage);
+    void UpdateDamagePerSecond(const float Duration);
+
+    float DamageLast = 0.0f;
+    float DamageMin = 0.0f;
+    float DamageMax = 0.0f;
+    float DamagePerFrame = 0.0f;
+    float DamagePerSecond = 0.0f;
+    float DamageTotal = 0.0f;
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+class FCogDamageStats
+{
+public:
+    void AddDamage(const float Damage, const float UnmitigatedDamage, const bool bIsCrit);
+    void Tick(const float DeltaSeconds);
+    void Restart();
+
+    int Count = 0;
+    int Crits = 0;
+    bool IsInProgress = false;
+    float TotalCritChances = 0.0f;
+    float Timer = 0.0f;
+    float MaxDuration = 0.0f;
+    float RestartTimer = 0.0f;
+
+    FCogDamageInstance Mitigated;
+    FCogDamageInstance Unmitigated;
+
+    static float MaxDurationSetting;
+    static float RestartDelaySetting;
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+UCLASS()
+class COGABILITY_API UCogAbilityWindow_Damages : public UCogWindow
+{
+    GENERATED_BODY()
+
+public:
+    UCogAbilityWindow_Damages();
+    virtual void RenderContent() override;
+    virtual void RenderTick(float DeltaSeconds) override;
+
+protected:
+    virtual void OnSelectionChanged(AActor* OldSelection, AActor* NewSelection) override;
+
+private:
+
+    UFUNCTION()
+    void OnDamageEvent(const FCogAbilityDamageParams& Params);
+
+    FCogDamageStats DamageDealtStats;
+    FCogDamageStats DamageReceivedStats;
+    FDelegateHandle OnDamageEventDelegate;
+};

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

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameplayTagContainer.h"
+#include "CogWindow.h"
+#include "CogAbilityWindow_Effects.generated.h"
+
+UCLASS()
+class COGABILITY_API UCogAbilityWindow_Effects : public UCogWindow
+{
+    GENERATED_BODY()
+
+public:
+
+    FGameplayTag NegativeEffectTag;
+
+    FGameplayTag PositiveEffectTag;
+
+protected:
+
+    virtual void PreRender(ImGuiWindowFlags& WindowFlags) override;
+
+    virtual void RenderContent() override;
+
+    virtual void DrawEffectRow(const UAbilitySystemComponent& AbilitySystemComponent, const FActiveGameplayEffectHandle& ActiveHandle, int32 Index, int32& Selected);
+
+    virtual void DrawEffectInfo(const UAbilitySystemComponent& AbilitySystemComponent, const FActiveGameplayEffect& ActiveEffect, const UGameplayEffect& Effect);
+    
+    virtual void DrawTagContainer(const FGameplayTagContainer& Container);
+
+    virtual FString GetEffectName(const UGameplayEffect& Effect);
+
+    virtual void DrawRemainingTime(const UAbilitySystemComponent& AbilitySystemComponent, const FActiveGameplayEffect& ActiveEffect);
+
+    virtual void DrawStacks(const FActiveGameplayEffect& ActiveEffect, const UGameplayEffect& Effect);
+
+    virtual void DrawPrediction(const FActiveGameplayEffect& ActiveEffect, bool Short);
+};

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

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameplayTagContainer.h"
+#include "CogWindow.h"
+#include "CogAbilityWindow_Pools.generated.h"
+
+class UCogAbilityDataAsset_Pools;
+
+UCLASS()
+class COGABILITY_API UCogAbilityWindow_Pools : public UCogWindow
+{
+    GENERATED_BODY()
+
+public:
+    UCogAbilityWindow_Pools();
+    virtual void RenderContent() override;
+
+    TWeakObjectPtr<UCogAbilityDataAsset_Pools> PoolsAsset;
+};

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

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "CogWindow.h"
+#include "CogAbilityWindow_Tags.generated.h"
+
+UCLASS()
+class COGABILITY_API UCogAbilityWindow_Tags : public UCogWindow
+{
+    GENERATED_BODY()
+
+public:
+    UCogAbilityWindow_Tags();
+
+    virtual void PreRender(ImGuiWindowFlags& WindowFlags) override;
+    virtual void RenderContent() override;
+};

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

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "CogWindow.h"
+#include "CogAbilityWindow_Tweaks.generated.h"
+
+class AActor;
+class UCogAbilityDataAsset_Tweaks;
+class ACogAbilityReplicator;
+
+UCLASS()
+class COGABILITY_API UCogAbilityWindow_Tweaks : public UCogWindow
+{
+    GENERATED_BODY()
+
+public:
+    UCogAbilityWindow_Tweaks();
+    virtual void RenderContent() override;
+
+    TWeakObjectPtr<UCogAbilityDataAsset_Tweaks> TweaksAsset;
+
+private:
+};