ab

Ability/Plugins/EzAbility/EzAbility.uplugin

@@ -25,5 +25,11 @@
 			"Type": "Editor",
 			"LoadingPhase": "Default"
 		}
+	],
+	"Plugins": [
+		{
+			"Name": "StructUtils",
+			"Enabled": true
+		}
 	]
 }

Ability/Plugins/EzAbility/Source/EzAbility/EzAbility.Build.cs

@@ -12,24 +12,24 @@ public class EzAbility : ModuleRules
 			new string[] {
 				// ... add public include paths required here ...
 			}
-			);
+		);
 				
 		
 		PrivateIncludePaths.AddRange(
 			new string[] {
 				// ... add other private include paths required here ...
 			}
-			);
+		);
 			
 		
 		PublicDependencyModuleNames.AddRange(
 			new string[]
 			{
 				"Core",
-				// ... add other public dependencies that you statically link with here ...
+				"StructUtils",
 				"DeveloperSettings",
 			}
-			);
+		);
 			
 		
 		PrivateDependencyModuleNames.AddRange(
@@ -39,16 +39,15 @@ public class EzAbility : ModuleRules
 				"Engine",
 				"Slate",
 				"SlateCore",
-				// ... add private dependencies that you statically link with here ...	
 			}
-			);
+		);
 		
 		
 		DynamicallyLoadedModuleNames.AddRange(
 			new string[]
 			{
-				// ... add any modules that your module loads dynamically here ...
+					// ... add any modules that your module loads dynamically here ...
 			}
-			);
+		);
 	}
 }

Ability/Plugins/EzAbility/Source/EzAbility/Private/Ability/EzGameAbilityBase.cpp → Ability/Plugins/EzAbility/Source/EzAbility/Private/Condition/EzAbilityCondition.cpp

@@ -1,4 +1,4 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 
 
-#include "Ability/EzGameAbilityBase.h"
+#include "Condition/EzAbilityCondition.h"

Ability/Plugins/EzAbility/Source/EzAbility/Private/Ability/EzGameAbilityPassive.cpp → Ability/Plugins/EzAbility/Source/EzAbility/Private/Evaluator/EzAbilityEvaluator.cpp

@@ -1,4 +1,4 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 
 
-#include "Ability/EzGameAbilityPassive.h"
+#include "Evaluator/EzAbilityEvaluator.h"

Ability/Plugins/EzAbility/Source/EzAbility/Private/EzAbility.cpp

@@ -2,19 +2,7 @@
 
 #include "EzAbility.h"
 
-#define LOCTEXT_NAMESPACE "FEzAbilityModule"
-
-void FEzAbilityModule::StartupModule()
+UEzAbility::UEzAbility(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
 {
-	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
 }
-
-void FEzAbilityModule::ShutdownModule()
-{
-	// This function may be called during shutdown to clean up your module.  For modules that support dynamic reloading,
-	// we call this function before unloading the module.
-}
-
-#undef LOCTEXT_NAMESPACE
-	
-IMPLEMENT_MODULE(FEzAbilityModule, EzAbility)

Ability/Plugins/EzAbility/Source/EzAbility/Private/EzAbilityContext.cpp

@@ -0,0 +1,13 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "EzAbilityContext.h"
+
+UEzAbilityContext::UEzAbilityContext(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}
+
+UEzAbilityContext::~UEzAbilityContext()
+{
+}

Ability/Plugins/EzAbility/Source/EzAbility/Private/EzAbilityModule.cpp

@@ -0,0 +1,27 @@
+#include "Modules/ModuleManager.h"
+
+class FEzAbilityModule : public IModuleInterface
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule() override;
+	virtual void ShutdownModule() override;
+};
+
+#define LOCTEXT_NAMESPACE "FEzAbilityModule"
+
+void FEzAbilityModule::StartupModule()
+{
+	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
+}
+
+void FEzAbilityModule::ShutdownModule()
+{
+	// This function may be called during shutdown to clean up your module.  For modules that support dynamic reloading,
+	// we call this function before unloading the module.
+}
+
+#undef LOCTEXT_NAMESPACE
+	
+IMPLEMENT_MODULE(FEzAbilityModule, EzAbility)

Ability/Plugins/EzAbility/Source/EzAbility/Private/Task/EzTaskBase.cpp → Ability/Plugins/EzAbility/Source/EzAbility/Private/EzAbilityNodeBase.cpp

@@ -1,4 +1,4 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 
 
-#include "Task/EzTaskBase.h"
+#include "EzAbilityNodeBase.h"

Ability/Plugins/EzAbility/Source/EzAbility/Private/EzAbilitySettingInterface.cpp

@@ -0,0 +1,7 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "EzAbilitySettingInterface.h"
+
+
+// Add default functionality here for any IEzAbilitySettingInterface functions that are not pure virtual.

Ability/Plugins/EzAbility/Source/EzAbility/Private/EzAbilitySettings.cpp

@@ -2,9 +2,23 @@
 
 
 #include "EzAbilitySettings.h"
+#include "EzAbilityContext.h"
 
 UEzAbilitySettings::UEzAbilitySettings(const FObjectInitializer& ObjectInitializer)
 {
 	CategoryName = TEXT("Plugins");
 	SectionName = TEXT("EzAbility");
 }
+
+bool UEzAbilitySettings::GetVerbose() const
+{
+	return bVerbose;
+}
+
+UClass* UEzAbilitySettings::GetAbilityContentClass() const
+{
+	return AbilityContentClass;
+}
+
+
+

Ability/Plugins/EzAbility/Source/EzAbility/Private/EzAbilityTypes.cpp

@@ -0,0 +1,51 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "EzAbilityTypes.h"
+
+const FEzAbilitySliceHandle FEzAbilitySliceHandle::Invalid		= FEzAbilitySliceHandle();
+const FEzAbilitySliceHandle FEzAbilitySliceHandle::Succeeded	= FEzAbilitySliceHandle(SucceededIndex);
+const FEzAbilitySliceHandle FEzAbilitySliceHandle::Failed		= FEzAbilitySliceHandle(FailedIndex);
+const FEzAbilitySliceHandle FEzAbilitySliceHandle::Stopped		= FEzAbilitySliceHandle(StoppedIndex);
+const FEzAbilitySliceHandle FEzAbilitySliceHandle::Root			= FEzAbilitySliceHandle(0);
+
+ESliceRunStatus FEzAbilitySliceHandle::ToCompletionStatus() const
+{
+	if (Index == SucceededIndex)
+	{
+		return ESliceRunStatus::Succeeded;
+	}
+
+	if (Index == FailedIndex)
+	{
+		return ESliceRunStatus::Failed;
+	}
+
+	if (Index == StoppedIndex)
+	{
+		return ESliceRunStatus::Stopped;
+	}
+	
+	return ESliceRunStatus::Unset;
+}
+
+FEzAbilitySliceHandle FEzAbilitySliceHandle::FromCompletionStatus(const ESliceRunStatus Status)
+{
+	switch (Status) {
+	case ESliceRunStatus::Failed:		return Failed;
+	case ESliceRunStatus::Succeeded:	return Succeeded;
+	case ESliceRunStatus::Stopped:		return Stopped;
+	case ESliceRunStatus::Running:
+	case ESliceRunStatus::Unset:		return {};
+	}
+	return {};
+}
+
+FCompactEzAbilitySlice::FCompactEzAbilitySlice()
+	: StartTime(0), EndTime(0)
+{
+}
+
+FCompactEzAbilityTransition::FCompactEzAbilityTransition()
+{
+}

Ability/Plugins/EzAbility/Source/EzAbility/Private/Ability/EzGameAbility.cpp → Ability/Plugins/EzAbility/Source/EzAbility/Private/Task/EzAbilityTask.cpp

@@ -1,4 +1,5 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 
 
-#include "Ability/EzGameAbility.h"
+#include "Task/EzAbilityTask.h"
+

Ability/Plugins/EzAbility/Source/EzAbility/Private/Transition/EzAbilityTransition.cpp

@@ -0,0 +1,4 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "Transition/EzAbilityTransition.h"

Ability/Plugins/EzAbility/Source/EzAbility/Public/Ability/EzGameAbility.h

@@ -1,16 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "EzGameAbilityBase.h"
-#include "EzGameAbility.generated.h"
-
-/**
- * 
- */
-UCLASS()
-class EZABILITY_API UEzGameAbility : public UEzGameAbilityBase
-{
-	GENERATED_BODY()
-};

Ability/Plugins/EzAbility/Source/EzAbility/Public/Ability/EzGameAbilityBase.h

@@ -1,23 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Runtime/CoreUObject/Public/UObject/Object.h"
-#include "EzGameAbilityBase.generated.h"
-
-class UEzTaskBase;
-
-/**
- * 
- */
-UCLASS(Abstract)
-class EZABILITY_API UEzGameAbilityBase : public UObject
-{
-	GENERATED_BODY()
-	
-protected:
-
-	UPROPERTY()
-	TArray<TObjectPtr<UEzTaskBase>>	OriginTasks;
-};

Ability/Plugins/EzAbility/Source/EzAbility/Public/Ability/EzGameAbilityPassive.h

@@ -1,16 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "EzGameAbilityBase.h"
-#include "EzGameAbilityPassive.generated.h"
-
-/**
- * 
- */
-UCLASS()
-class EZABILITY_API UEzGameAbilityPassive : public UEzGameAbilityBase
-{
-	GENERATED_BODY()
-};

Ability/Plugins/EzAbility/Source/EzAbility/Public/Condition/EzAbilityCondition.h

@@ -0,0 +1,17 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "EzAbilityNodeBase.h"
+#include "UObject/Object.h"
+#include "EzAbilityCondition.generated.h"
+
+/**
+ * 
+ */
+USTRUCT()
+struct EZABILITY_API FEzAbilityCondition : public FEzAbilityNodeBase
+{
+	GENERATED_BODY()
+};

Ability/Plugins/EzAbility/Source/EzAbility/Public/Evaluator/EzAbilityEvaluator.h

@@ -0,0 +1,17 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "EzAbilityNodeBase.h"
+#include "UObject/Object.h"
+#include "EzAbilityEvaluator.generated.h"
+
+/**
+ * 
+ */
+USTRUCT()
+struct EZABILITY_API FEzAbilityEvaluator : public FEzAbilityNodeBase
+{
+	GENERATED_BODY()
+};

Ability/Plugins/EzAbility/Source/EzAbility/Public/EzAbility.h

@@ -3,15 +3,29 @@
 #pragma once
 
 #include "CoreMinimal.h"
-#include "Modules/ModuleManager.h"
+#include "InstancedStructContainer.h"
+#include "EzAbilityTypes.h"
+#include "EzAbility.generated.h"
 
-DECLARE_LOG_CATEGORY_EXTERN(LogEzAbility, Log, All);
 
-class FEzAbilityModule : public IModuleInterface
+UCLASS(Blueprintable, hidecategories=(Internal, Thumbnail), meta = (ShowWorldContextPin, DisplayThumbnail = "true"))
+class UEzAbility : public UDataAsset
 {
+	GENERATED_BODY()
 public:
+	UEzAbility(const FObjectInitializer& ObjectInitializer);
 
-	/** IModuleInterface implementation */
-	virtual void StartupModule() override;
-	virtual void ShutdownModule() override;
+protected:
+
+	//Slices
+	UPROPERTY()
+	TArray<FCompactEzAbilitySlice>		Slices;
+
+	//Condition, Evaluator, Task
+	UPROPERTY()
+	FInstancedStructContainer			Nodes;
+
+	//Transitions
+	UPROPERTY()
+	TArray<FCompactEzAbilityTransition> Transitions;
 };

Ability/Plugins/EzAbility/Source/EzAbility/Public/EzAbilityComponent.h

@@ -6,6 +6,7 @@
 #include "Runtime/Engine/Classes/Components/ActorComponent.h"
 #include "EzAbilityComponent.generated.h"
 
+class UEzAbilityContext;
 
 UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
 class EZABILITY_API UEzAbilityComponent : public UActorComponent
@@ -28,4 +29,6 @@ public:
 	void ActiveAbility();
 
 protected:
+	UPROPERTY(Transient)
+	TObjectPtr<UEzAbilityContext>	AbilityContext;
 };

Ability/Plugins/EzAbility/Source/EzAbility/Public/EzAbilityContext.h

@@ -0,0 +1,34 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "UObject/Object.h"
+#include "EzAbilityContext.generated.h"
+
+class UEzAbilityComponent;
+
+/**
+ * 
+ */
+UCLASS()
+class EZABILITY_API UEzAbilityContext : public UObject
+{
+	GENERATED_BODY()
+public:
+	UEzAbilityContext(const FObjectInitializer& ObjectInitializer);
+	virtual ~UEzAbilityContext();
+	
+protected:
+	UPROPERTY(Transient)
+	TObjectPtr<UEzAbilityComponent>	Component;
+
+	UPROPERTY(Transient)
+	TWeakObjectPtr<AActor>	Owner;
+
+	UPROPERTY(Transient)
+	TWeakObjectPtr<AActor>	Instigator;
+
+	UPROPERTY(Transient)
+	TArray<TWeakObjectPtr<AActor>>	TargetActors;
+};

Ability/Plugins/EzAbility/Source/EzAbility/Public/EzAbilityLog.h

@@ -3,6 +3,5 @@
 #pragma once
 
 #include "CoreMinimal.h"
-#include "Modules/ModuleManager.h"
 
 EZABILITY_API DECLARE_LOG_CATEGORY_EXTERN(LogEzAbility, Log, All);

Ability/Plugins/EzAbility/Source/EzAbility/Public/EzAbilityNodeBase.h

@@ -0,0 +1,30 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "UObject/Object.h"
+#include "EzAbilityNodeBase.generated.h"
+
+/**
+ * 
+ */
+USTRUCT()
+struct EZABILITY_API FEzAbilityNodeBase
+{
+	GENERATED_BODY()
+
+PRAGMA_DISABLE_DEPRECATION_WARNINGS
+	FEzAbilityNodeBase() = default;
+	FEzAbilityNodeBase(const FEzAbilityNodeBase&) = default;
+	FEzAbilityNodeBase(FEzAbilityNodeBase&&) = default;
+	FEzAbilityNodeBase& operator=(const FEzAbilityNodeBase&) = default;
+	FEzAbilityNodeBase& operator=(FEzAbilityNodeBase&&) = default;
+PRAGMA_ENABLE_DEPRECATION_WARNINGS
+
+	virtual ~FEzAbilityNodeBase() = default;
+
+	virtual UStruct* GetInstanceDataType() const { return nullptr; }
+	virtual bool Link() { return false; }
+	
+};

Ability/Plugins/EzAbility/Source/EzAbility/Public/EzAbilitySettingInterface.h

@@ -0,0 +1,27 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "UObject/Interface.h"
+#include "EzAbilitySettingInterface.generated.h"
+
+// This class does not need to be modified.
+UINTERFACE()
+class UEzAbilitySettingInterface : public UInterface
+{
+	GENERATED_BODY()
+};
+
+/**
+ * 
+ */
+class EZABILITY_API IEzAbilitySettingInterface
+{
+	GENERATED_BODY()
+
+	// Add interface functions to this class. This is the class that will be inherited to implement this interface.
+public:
+	virtual bool	GetVerbose()				const = 0;
+	virtual UClass* GetAbilityContentClass()	const = 0;
+};

Ability/Plugins/EzAbility/Source/EzAbility/Public/EzAbilitySettings.h

@@ -3,20 +3,28 @@
 #pragma once
 
 #include "CoreMinimal.h"
+#include "EzAbilitySettingInterface.h"
 #include "Engine/DeveloperSettings.h"
 #include "EzAbilitySettings.generated.h"
 
+class UEzAbilityContext;
+
 /**
  * 
  */
 UCLASS(Config=EzAbility)
-class EZABILITY_API UEzAbilitySettings : public UDeveloperSettings
+class EZABILITY_API UEzAbilitySettings : public UDeveloperSettings, public IEzAbilitySettingInterface
 {
 	GENERATED_BODY()
 public:
 	UEzAbilitySettings(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
+	virtual bool	GetVerbose()				const override;
+	virtual UClass* GetAbilityContentClass()	const override;
 protected:
-	UPROPERTY(Config, EditAnywhere, Category = Ability, meta = (DisplayName = "Log Verbose Output"))
+	UPROPERTY(Config, EditAnywhere, Category = Debug, meta = (DisplayName = "Log Verbose Output"))
 	bool bVerbose = false;
+	
+	UPROPERTY(Config, EditAnywhere, Category = Ability)
+	TSubclassOf<UEzAbilityContext>	AbilityContentClass;
 };

Ability/Plugins/EzAbility/Source/EzAbility/Public/EzAbilityTypes.h

@@ -0,0 +1,127 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "UObject/Object.h"
+#include "EzAbilityTypes.generated.h"
+
+UENUM(BlueprintType)
+enum class ESliceRunStatus : uint8
+{
+	Running,
+	Failed,
+	Succeeded,
+	Stopped,
+	Unset,
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+///Slice
+UENUM()
+enum class ESliceType
+{
+	Main,
+	Parallel,
+};
+
+USTRUCT(BlueprintType)
+struct EZABILITY_API FEzAbilitySliceHandle
+{
+	GENERATED_BODY()
+
+	static constexpr uint16 InvalidIndex	= uint16(-1);		// Index value indicating invalid state.
+	static constexpr uint16 SucceededIndex	= uint16(-2);		// Index value indicating a Succeeded state.
+	static constexpr uint16 FailedIndex		= uint16(-3);		// Index value indicating a Failed state.
+	static constexpr uint16 StoppedIndex	= uint16(-4);		// Index value indicating a Stopped state.
+
+	static const FEzAbilitySliceHandle Invalid;
+	static const FEzAbilitySliceHandle Succeeded;
+	static const FEzAbilitySliceHandle Failed;
+	static const FEzAbilitySliceHandle Stopped;
+	static const FEzAbilitySliceHandle Root;
+
+	static bool IsValidIndex(const int32 Index) { return Index >= 0 && Index < (int32)MAX_uint16; }
+	friend FORCEINLINE uint32 GetTypeHash(const FEzAbilitySliceHandle& Handle) { return GetTypeHash(Handle.Index); }
+
+	FEzAbilitySliceHandle() = default;
+	explicit FEzAbilitySliceHandle(const uint16 InIndex) : Index(InIndex) {}
+	explicit FEzAbilitySliceHandle(const int32 InIndex) : Index()
+	{
+		check(InIndex == INDEX_NONE || IsValidIndex(InIndex));
+		Index = InIndex == INDEX_NONE ? InvalidIndex : static_cast<uint16>(InIndex);	
+	}
+
+	bool IsValid() const { return Index != InvalidIndex; }
+	void Invalidate() { Index = InvalidIndex; }
+	bool IsCompletionState() const { return Index == SucceededIndex || Index == FailedIndex || Index == StoppedIndex; }
+	
+	bool operator==(const FEzAbilitySliceHandle& RHS) const { return Index == RHS.Index; }
+	bool operator!=(const FEzAbilitySliceHandle& RHS) const { return Index != RHS.Index; }
+	
+	FString Describe() const
+	{
+		switch (Index)
+		{
+		case InvalidIndex:		return TEXT("Invalid");
+		case SucceededIndex:	return TEXT("Succeeded");
+		case FailedIndex: 		return TEXT("Failed");
+		case StoppedIndex: 		return TEXT("Stopped");
+		default: 				return FString::Printf(TEXT("%d"), Index);
+		}
+	}
+
+	ESliceRunStatus ToCompletionStatus() const;
+	static FEzAbilitySliceHandle FromCompletionStatus(const ESliceRunStatus Status);
+	
+	UPROPERTY()
+	uint16 Index = InvalidIndex;
+};
+
+USTRUCT()
+struct EZABILITY_API FCompactEzAbilitySlice
+{
+	GENERATED_BODY()
+
+	FCompactEzAbilitySlice();
+
+	uint16	GetNextIndex()	const { return ChildrenEnd; };
+	bool	HasChildren()	const { return ChildrenEnd > ChildrenBegin; };
+
+	UPROPERTY()
+	uint8 bEnabled : 1;
+	
+	UPROPERTY()
+	ESliceType Type = ESliceType::Main;
+	
+	UPROPERTY()
+	FName Name;
+
+	UPROPERTY()
+	FEzAbilitySliceHandle Parent = FEzAbilitySliceHandle::Invalid;
+	
+	UPROPERTY()
+	float	StartTime;
+
+	UPROPERTY()
+	float	EndTime;
+	
+	UPROPERTY()
+	uint16 ChildrenBegin = 0;
+	
+	UPROPERTY()
+	uint16 ChildrenEnd = 0;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+///Transition
+USTRUCT()
+struct EZABILITY_API FCompactEzAbilityTransition
+{
+	GENERATED_BODY()
+
+	FCompactEzAbilityTransition();
+	
+	UPROPERTY()
+	FEzAbilitySliceHandle State = FEzAbilitySliceHandle::Invalid;
+};

Ability/Plugins/EzAbility/Source/EzAbility/Public/Task/EzTaskBase.h → Ability/Plugins/EzAbility/Source/EzAbility/Public/Task/EzAbilityTask.h

@@ -4,13 +4,14 @@
 
 #include "CoreMinimal.h"
 #include "UObject/Object.h"
-#include "EzTaskBase.generated.h"
+#include "EzAbilityTask.generated.h"
 
 /**
  * 
  */
-UCLASS(Abstract)
-class EZABILITY_API UEzTaskBase : public UObject
+USTRUCT()
+struct EZABILITY_API FEzAbilityTask
 {
 	GENERATED_BODY()
+	
 };

Ability/Plugins/EzAbility/Source/EzAbility/Public/Transition/EzAbilityTransition.h

@@ -0,0 +1,17 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "EzAbilityNodeBase.h"
+#include "UObject/Object.h"
+#include "EzAbilityTransition.generated.h"
+
+/**
+ * 
+ */
+USTRUCT()
+struct EZABILITY_API FEzAbilityTransition : public FEzAbilityNodeBase
+{
+	GENERATED_BODY()
+};