ab

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

@@ -1,7 +1,7 @@
 #include "EzAbility.h"
 #include "EzAbilityComponent.h"
 
-bool UEzAbilityComponent::InternalActivateAbility(const UEzAbility* Ability, const FEzAbilityParameter& Parameter)
+bool UEzAbilityComponent::InternalActivateAbility(UEzAbility* Ability, const FEzAbilityParameter& Parameter)
 {
 	if(Ability == nullptr)
 	{
@@ -25,11 +25,11 @@ bool UEzAbilityComponent::InternalActivateAbility(const UEzAbility* Ability, con
 	return true;
 }
 
-void UEzAbilityComponent::NotifyAbilityFailed(const UEzAbility* Ability, const FText& Text)
+void UEzAbilityComponent::NotifyAbilityFailed(UEzAbility* Ability, const FText& Text)
 {
 }
 
-bool UEzAbilityComponent::ActivateAbility(const UEzAbility* Ability, const FEzAbilityParameter& Parameter)
+bool UEzAbilityComponent::ActivateAbility(UEzAbility* Ability, const FEzAbilityParameter& Parameter)
 {
 	if(Ability == nullptr)
 	{
@@ -56,7 +56,7 @@ bool UEzAbilityComponent::ActivateAbility(const UEzAbility* Ability, const FEzAb
 	return InternalActivateAbility(Ability, Parameter);
 }
 
-bool UEzAbilityComponent::ActivateAbility_NoParameter(const UEzAbility* Ability)
+bool UEzAbilityComponent::ActivateAbility_NoParameter(UEzAbility* Ability)
 {
 	FEzAbilityParameter Parameter;
 	return ActivateAbility(Ability, Parameter);
@@ -101,12 +101,12 @@ bool UEzAbilityComponent::ServerEndAbility_Validate()
 	return true;
 }
 
-void UEzAbilityComponent::ServerActivateAbility_Implementation(const UEzAbility* Ability, const FEzAbilityParameter& Parameter)
+void UEzAbilityComponent::ServerActivateAbility_Implementation(UEzAbility* Ability, const FEzAbilityParameter& Parameter)
 {
 	InternalActivateAbility(Ability, Parameter);
 }
 
-bool UEzAbilityComponent::ServerActivateAbility_Validate(const UEzAbility* Ability, const FEzAbilityParameter& Parameter)
+bool UEzAbilityComponent::ServerActivateAbility_Validate(UEzAbility* Ability, const FEzAbilityParameter& Parameter)
 {
 	return true;
 }

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

@@ -54,7 +54,7 @@ bool FEzAbilityContext::IsLocallyControlled() const
 
 bool FEzAbilityContext::IsNetAuthority() const
 {
-	if (const AActor* OwnerActorPtr = OwnerActor.Get(true))
+	if (const AActor* OwnerActorPtr = OwnerActor)
 	{
 		return (OwnerActorPtr->GetLocalRole() == ROLE_Authority);
 	}
@@ -62,16 +62,26 @@ bool FEzAbilityContext::IsNetAuthority() const
 	return false;
 }
 
-EAbilityRunStatus FEzAbilityContext::Start(const UEzAbility* InAbility, const FEzAbilityParameter& Parameter, FText& OutText)
+EAbilityRunStatus FEzAbilityContext::Start(UEzAbility* InAbility, const FEzAbilityParameter& Parameter, FText& OutText)
 {
 	if(Ability != nullptr)
 	{
 		//TODO 打断技能
 	}
 
-	//TODO 初始化技能信息
+	Reset();
 	
-	return EAbilityRunStatus::Failed;
+	Ability						= InAbility;
+	Instigator					= Parameter.Instigator;
+	Target.DefaultLocations		= Parameter.Locations;
+	Target.DefaultTargets		= Parameter.Targets;
+
+
+	//TODO 设置默认参数
+	//TODO 设置InstanceData
+	
+	
+	return EAbilityRunStatus::Succeeded;
 }
 
 // EAbilityRunStatus FEzAbilityContext::Tick(float DeltaTime)
@@ -88,3 +98,9 @@ EAbilityRunStatus FEzAbilityContext::GetAbilityRunStatus() const
 {
 	return EAbilityRunStatus::Failed;
 }
+
+void FEzAbilityContext::Reset()
+{
+	Instigator = nullptr;
+	Target.Reset();
+}

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

@@ -0,0 +1,405 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "EzAbilityInstanceData.h"
+#include "EzAbility.h"
+#include "EzAbilityLog.h"
+#include "Serialization/ObjectAndNameAsStringProxyArchive.h"
+
+namespace EzAbility
+{
+
+	/**
+	 * Duplicates object, and tries to covert old BP classes (REINST_*) to their newer version.
+	 */
+	UObject* DuplicateNodeInstance(const UObject& Instance, UObject& InOwner)
+	{
+		const UClass* InstanceClass = Instance.GetClass();
+		if (InstanceClass->HasAnyClassFlags(CLASS_NewerVersionExists))
+		{
+			const UClass* AuthoritativeClass = InstanceClass->GetAuthoritativeClass();
+			UObject* NewInstance = NewObject<UObject>(&InOwner, AuthoritativeClass);
+
+			// Try to copy the values over using serialization
+			// FObjectAndNameAsStringProxyArchive is used to store and restore names and objects as memory writer does not support UObject references at all.
+			TArray<uint8> Data;
+			FMemoryWriter Writer(Data);
+			FObjectAndNameAsStringProxyArchive WriterProxy(Writer, /*bInLoadIfFindFails*/true);
+			UObject& NonConstInstance = const_cast<UObject&>(Instance);
+			NonConstInstance.Serialize(WriterProxy);
+
+			FMemoryReader Reader(Data);
+			FObjectAndNameAsStringProxyArchive ReaderProxy(Reader, /*bInLoadIfFindFails*/true);
+			NewInstance->Serialize(ReaderProxy);
+
+			const UEzAbility* OuterAbility = Instance.GetTypedOuter<UEzAbility>();
+
+			UE_LOG(LogEzAbility, Display, TEXT("FEzAbilityInstanceData: Duplicating '%s' with old class '%s' as '%s', potential data loss. Please resave EzAbility asset %s."),
+				*GetFullNameSafe(&Instance), *GetNameSafe(InstanceClass), *GetNameSafe(AuthoritativeClass), *GetFullNameSafe(OuterAbility));
+
+			return NewInstance;
+		}
+
+		return DuplicateObject(&Instance, &InOwner);
+	}
+
+// #if WITH_EDITORONLY_DATA
+// 	void GatherForLocalization(const FString& PathToParent, const UScriptStruct* Struct, const void* StructData, const void* DefaultStructData, FPropertyLocalizationDataGatherer& PropertyLocalizationDataGatherer, const EPropertyLocalizationGathererTextFlags GatherTextFlags)
+// 	{
+// 		const FStateTreeInstanceData* ThisInstance = static_cast<const FStateTreeInstanceData*>(StructData);
+// 		const FStateTreeInstanceData* DefaultInstance = static_cast<const FStateTreeInstanceData*>(DefaultStructData);
+//
+// 		PropertyLocalizationDataGatherer.GatherLocalizationDataFromStruct(PathToParent, Struct, StructData, DefaultStructData, GatherTextFlags);
+//
+// 		const uint8* DefaultInstanceMemory = nullptr;
+// 		if (DefaultInstance)
+// 		{
+// 			DefaultInstanceMemory = reinterpret_cast<const uint8*>(&DefaultInstance->GetStorage());
+// 		}
+// 		
+// 		const UScriptStruct* StructTypePtr = FStateTreeInstanceStorage::StaticStruct();
+// 		PropertyLocalizationDataGatherer.GatherLocalizationDataFromStructWithCallbacks(PathToParent + TEXT(".InstanceStorage"), StructTypePtr, &ThisInstance->GetStorage(), DefaultInstanceMemory, GatherTextFlags);
+// 	}
+//
+// 	void RegisterInstanceDataForLocalization()
+// 	{
+// 		{ static const FAutoRegisterLocalizationDataGatheringCallback AutomaticRegistrationOfLocalizationGatherer(TBaseStructure<FStateTreeInstanceData>::Get(), &GatherForLocalization); }
+// 	}
+// #endif // WITH_EDITORONLY_DATA
+
+} 
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+///InstanceStorage
+void FEzAbilityInstanceStorage::Reset()
+{
+	InstanceStructs.Reset();
+	TemporaryInstances.Reset();
+}
+
+const UObject* FEzAbilityInstanceStorage::GetObject(const int32 Index) const
+{
+	const FEzAbilityInstanceObjectWrapper& Wrapper = InstanceStructs[Index].Get<const FEzAbilityInstanceObjectWrapper>();
+	return Wrapper.InstanceObject;
+}
+
+UObject* FEzAbilityInstanceStorage::GetMutableObject(const int32 Index) const
+{
+	const FEzAbilityInstanceObjectWrapper& Wrapper = InstanceStructs[Index].Get<const FEzAbilityInstanceObjectWrapper>();
+	return Wrapper.InstanceObject;
+}
+
+bool FEzAbilityInstanceStorage::AreAllInstancesValid() const
+{
+	for (FConstStructView Instance : InstanceStructs)
+	{
+		if (!Instance.IsValid())
+		{
+			return false;
+		}
+		if (const FEzAbilityInstanceObjectWrapper* Wrapper = Instance.GetPtr<const FEzAbilityInstanceObjectWrapper>())
+		{
+			if (!Wrapper->InstanceObject)
+			{
+				return false;
+			}
+		}
+	}
+	return true;
+}
+
+void FEzAbilityInstanceStorage::ResetTemporaryInstances()
+{
+	TemporaryInstances.Reset();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+///InstanceData
+
+FEzAbilityInstanceData::FEzAbilityInstanceData(const FEzAbilityInstanceData& Other)
+{
+	InstanceStorage = MakeShared<FEzAbilityInstanceStorage>(*Other.InstanceStorage);
+}
+
+FEzAbilityInstanceData::FEzAbilityInstanceData(FEzAbilityInstanceData&& Other)
+{
+	InstanceStorage = Other.InstanceStorage;
+	Other.InstanceStorage = MakeShared<FEzAbilityInstanceStorage>();
+}
+
+FEzAbilityInstanceData::~FEzAbilityInstanceData()
+{
+}
+
+FEzAbilityInstanceData& FEzAbilityInstanceData::operator=(const FEzAbilityInstanceData& Other)
+{
+	InstanceStorage = MakeShared<FEzAbilityInstanceStorage>(*Other.InstanceStorage);
+	return *this;
+}
+
+FEzAbilityInstanceData& FEzAbilityInstanceData::operator=(FEzAbilityInstanceData&& Other)
+{
+	InstanceStorage = Other.InstanceStorage;
+	Other.InstanceStorage = MakeShared<FEzAbilityInstanceStorage>();
+	return *this;
+}
+
+void FEzAbilityInstanceData::Reset()
+{
+	FEzAbilityInstanceStorage& Storage = GetMutableStorage();
+	Storage.Reset();
+}
+
+void FEzAbilityInstanceData::Init(UObject& InOwner, TConstArrayView<FInstancedStruct> InStructs)
+{
+	Reset();
+	Append(InOwner, InStructs);
+}
+
+void FEzAbilityInstanceData::Init(UObject& InOwner, TConstArrayView<FConstStructView> InStructs)
+{
+	Reset();
+	Append(InOwner, InStructs);
+}
+
+void FEzAbilityInstanceData::Append(UObject& InOwner, TConstArrayView<FInstancedStruct> InStructs) const
+{
+	FEzAbilityInstanceStorage& Storage = GetMutableStorage();
+
+	const int32 StartIndex = Storage.InstanceStructs.Num();
+	Storage.InstanceStructs.Append(InStructs);
+
+	for (int32 Index = StartIndex; Index < Storage.InstanceStructs.Num(); Index++)
+	{
+		if (FEzAbilityInstanceObjectWrapper* Wrapper = Storage.InstanceStructs[Index].GetPtr<FEzAbilityInstanceObjectWrapper>())
+		{
+			if (Wrapper->InstanceObject)
+			{
+				Wrapper->InstanceObject = EzAbility::DuplicateNodeInstance(*Wrapper->InstanceObject, InOwner);
+			}
+		}
+	}
+}
+
+void FEzAbilityInstanceData::Append(UObject& InOwner, TConstArrayView<FConstStructView> InStructs) const
+{
+	FEzAbilityInstanceStorage& Storage = GetMutableStorage();
+
+	const int32 StartIndex = Storage.InstanceStructs.Num();
+	Storage.InstanceStructs.Append(InStructs);
+	
+	for (int32 Index = StartIndex; Index < Storage.InstanceStructs.Num(); Index++)
+	{
+		if (FEzAbilityInstanceObjectWrapper* Wrapper = Storage.InstanceStructs[Index].GetPtr<FEzAbilityInstanceObjectWrapper>())
+		{
+			if (Wrapper->InstanceObject)
+			{
+				Wrapper->InstanceObject = EzAbility::DuplicateNodeInstance(*Wrapper->InstanceObject, InOwner);
+			}
+		}
+	}
+}
+
+void FEzAbilityInstanceData::Append(UObject& InOwner, TConstArrayView<FConstStructView> InStructs, TConstArrayView<FInstancedStruct*> InInstancesToMove) const
+{
+	check(InStructs.Num() == InInstancesToMove.Num());
+	
+	FEzAbilityInstanceStorage& Storage = GetMutableStorage();
+
+	const int32 StartIndex = Storage.InstanceStructs.Num();
+	Storage.InstanceStructs.Append(InStructs);
+
+	for (int32 Index = StartIndex; Index < Storage.InstanceStructs.Num(); Index++)
+	{
+		FStructView Struct = Storage.InstanceStructs[Index];
+		FInstancedStruct* Source = InInstancesToMove[Index - StartIndex];
+
+		// The source is used to move temporary instance data into instance data. Not all entries may have it.
+		// The instance struct can be empty, in which case the temporary instance is ignored.
+		// If the source is specified, move it to the instance data.
+		// We assume that if the source is object wrapper, it is already the instance we want.
+		if (Struct.IsValid() && (Source && Source->IsValid()))
+		{
+			check(Struct.GetScriptStruct() == Source->GetScriptStruct());
+				
+			FMemory::Memswap(Struct.GetMemory(), Source->GetMutableMemory(), Struct.GetScriptStruct()->GetStructureSize());
+			Source->Reset();
+		}
+		else if (FEzAbilityInstanceObjectWrapper* Wrapper = Struct.GetPtr<FEzAbilityInstanceObjectWrapper>())
+		{
+			if (Wrapper->InstanceObject)
+			{
+				Wrapper->InstanceObject = EzAbility::DuplicateNodeInstance(*Wrapper->InstanceObject, InOwner);
+			}
+		}
+	}
+}
+
+void FEzAbilityInstanceData::ShrinkTo(const int32 Num) const
+{
+	FEzAbilityInstanceStorage& Storage = GetMutableStorage();
+	check(Num <= Storage.InstanceStructs.Num());  
+	Storage.InstanceStructs.SetNum(Num);
+}
+
+void FEzAbilityInstanceData::CopyFrom(UObject& InOwner, const FEzAbilityInstanceData& InOther) const
+{
+	if (&InOther == this)
+	{
+		return;
+	}
+
+	FEzAbilityInstanceStorage& Storage = GetMutableStorage();
+	const FEzAbilityInstanceStorage& OtherStorage = InOther.GetStorage();
+
+	// Copy structs
+	Storage.InstanceStructs = OtherStorage.InstanceStructs;
+
+	// Copy instance objects.
+	for (FStructView Instance : Storage.InstanceStructs)
+	{
+		if (FEzAbilityInstanceObjectWrapper* Wrapper = Instance.GetPtr<FEzAbilityInstanceObjectWrapper>())
+		{
+			if (Wrapper->InstanceObject)
+			{
+				Wrapper->InstanceObject = EzAbility::DuplicateNodeInstance(*Wrapper->InstanceObject, InOwner);
+			}
+		}
+	}
+}
+
+bool FEzAbilityInstanceData::AreAllInstancesValid() const
+{
+	return GetStorage().AreAllInstancesValid();
+}
+
+int32 FEzAbilityInstanceData::GetEstimatedMemoryUsage() const
+{
+	const FEzAbilityInstanceStorage& Storage = GetStorage();
+	int32 Size = sizeof(FEzAbilityInstanceData);
+
+	Size += Storage.InstanceStructs.GetAllocatedMemory();
+
+	for (FConstStructView Instance : Storage.InstanceStructs)
+	{
+		if (const FEzAbilityInstanceObjectWrapper* Wrapper = Instance.GetPtr<const FEzAbilityInstanceObjectWrapper>())
+		{
+			if (Wrapper->InstanceObject)
+			{
+				Size += Wrapper->InstanceObject->GetClass()->GetStructureSize();
+			}
+		}
+	}
+
+	return Size;
+}
+
+bool FEzAbilityInstanceData::Identical(const FEzAbilityInstanceData* Other, uint32 PortFlags) const
+{
+	if (Other == nullptr)
+	{
+		return false;
+	}
+
+	const FEzAbilityInstanceStorage& Storage = GetStorage();
+	const FEzAbilityInstanceStorage& OtherStorage = Other->GetStorage();
+
+	// Not identical if global parameters don't match.
+	// if (!Storage.GlobalParameters.Identical(&OtherStorage.GlobalParameters, PortFlags))
+	// {
+	// 	return false;
+	// }
+
+	// Not identical if structs are different.
+	if (Storage.InstanceStructs.Identical(&OtherStorage.InstanceStructs, PortFlags) == false)
+	{
+		return false;
+	}
+	
+	// Check that the instance object contents are identical.
+	// Copied from object property.
+	auto AreObjectsIdentical = [](UObject* A, UObject* B, uint32 PortFlags) -> bool
+	{
+		if ((PortFlags & PPF_DuplicateForPIE) != 0)
+		{
+			return false;
+		}
+
+		if (A == B)
+		{
+			return true;
+		}
+
+		// Resolve the object handles and run the deep comparison logic 
+		if ((PortFlags & (PPF_DeepCompareInstances | PPF_DeepComparison)) != 0)
+		{
+			return FObjectPropertyBase::StaticIdentical(A, B, PortFlags);
+		}
+
+		return true;
+	};
+
+	bool bResult = true;
+
+	for (int32 Index = 0; Index < Storage.InstanceStructs.Num(); Index++)
+	{
+		const FEzAbilityInstanceObjectWrapper* Wrapper = Storage.InstanceStructs[Index].GetPtr<const FEzAbilityInstanceObjectWrapper>();
+		const FEzAbilityInstanceObjectWrapper* OtherWrapper = OtherStorage.InstanceStructs[Index].GetPtr<const FEzAbilityInstanceObjectWrapper>();
+
+		if (Wrapper)
+		{
+			if (!OtherWrapper)
+			{
+				bResult = false;
+				break;
+			}
+			if (Wrapper->InstanceObject && OtherWrapper->InstanceObject)
+			{
+				if (!AreObjectsIdentical(Wrapper->InstanceObject, OtherWrapper->InstanceObject, PortFlags))
+				{
+					bResult = false;
+					break;
+				}
+			}
+		}
+	}
+	
+	return bResult;
+}
+
+void FEzAbilityInstanceData::AddStructReferencedObjects(FReferenceCollector& Collector)
+{
+	Collector.AddPropertyReferencesWithStructARO(FEzAbilityInstanceStorage::StaticStruct(), &GetMutableStorage());
+}
+
+bool FEzAbilityInstanceData::Serialize(FArchive& Ar)
+{
+	if (Ar.IsLoading())
+	{
+		InstanceStorage = MakeShared<FEzAbilityInstanceStorage>();
+	}
+
+	FEzAbilityInstanceStorage::StaticStruct()->SerializeItem(Ar, &InstanceStorage.Get(), nullptr);
+
+	return true;
+}
+
+void FEzAbilityInstanceData::GetPreloadDependencies(TArray<UObject*>& OutDeps)
+{
+	UScriptStruct* ScriptStruct = FEzAbilityInstanceStorage::StaticStruct();
+	OutDeps.Add(ScriptStruct);
+
+	if (UScriptStruct::ICppStructOps* CppStructOps = ScriptStruct->GetCppStructOps())
+	{
+		CppStructOps->GetPreloadDependencies(&GetMutableStorage(), OutDeps);
+	}
+
+	for (TPropertyValueIterator<FStructProperty> It(ScriptStruct, &GetMutableStorage()); It; ++It)
+	{
+		const UScriptStruct* StructType = It.Key()->Struct;
+		if (UScriptStruct::ICppStructOps* CppStructOps = StructType->GetCppStructOps())
+		{
+			void* StructDataPtr = const_cast<void*>(It.Value());
+			CppStructOps->GetPreloadDependencies(StructDataPtr, OutDeps);
+		}
+	}
+}

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

@@ -60,10 +60,10 @@ public:
 	//////////////////////////////////////////////////////////////////////////////////////////////////////////
 	///Ability
 	UFUNCTION(BlueprintCallable, Category="Ability")
-	bool ActivateAbility(const UEzAbility* Ability, const FEzAbilityParameter& Parameter);
+	bool ActivateAbility(UEzAbility* Ability, const FEzAbilityParameter& Parameter);
 
 	UFUNCTION(BlueprintCallable, meta=(DisplayName="ActivateAbility"), Category="Ability")
-	bool ActivateAbility_NoParameter(const UEzAbility* Ability);
+	bool ActivateAbility_NoParameter(UEzAbility* Ability);
 	
 	UFUNCTION(BlueprintCallable, Category="Ability")
 	bool CancelAbility();
@@ -75,9 +75,9 @@ public:
 
 protected:
 	void CacheIsNetSimulated();
-	bool InternalActivateAbility(const UEzAbility* Ability, const FEzAbilityParameter& Parameter);
+	bool InternalActivateAbility(UEzAbility* Ability, const FEzAbilityParameter& Parameter);
 
-	void NotifyAbilityFailed(const UEzAbility* Ability, const FText& Text);
+	void NotifyAbilityFailed(UEzAbility* Ability, const FText& Text);
 	
 	UFUNCTION()
 	void OnRep_AbilityInstance();
@@ -86,7 +86,7 @@ protected:
 	void OnRep_PassiveAbilityInstances();
 	
 	UFUNCTION(Server, reliable, WithValidation)
-	void ServerActivateAbility(const UEzAbility* Ability, const FEzAbilityParameter& Parameter);
+	void ServerActivateAbility(UEzAbility* Ability, const FEzAbilityParameter& Parameter);
 	
 	UFUNCTION(Client, reliable)
 	void ClientActivateAbility();

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

@@ -9,7 +9,32 @@
 
 class UEzAbilityComponent;
 class UEzAbility;
-struct FEzAbilityParameter;
+
+USTRUCT(BlueprintType)
+struct FEzAbilityTarget
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere)
+	TArray<TObjectPtr<AActor>>		DefaultTargets;
+
+	UPROPERTY(EditAnywhere)
+	TArray<FVector>					DefaultLocations;
+
+	UPROPERTY(EditAnywhere)
+	TArray<TObjectPtr<AActor>>		Targets;
+
+	UPROPERTY(EditAnywhere)
+	TArray<FVector>					Locations;
+
+	void Reset()
+	{
+		DefaultTargets.Empty();
+		DefaultLocations.Empty();
+		Targets.Empty();
+		Locations.Empty();
+	}
+};
 
 /**
  * 
@@ -23,27 +48,28 @@ public:
 	bool IsLocallyControlled() const;
 	bool IsNetAuthority() const;
 	
-	EAbilityRunStatus Start(const UEzAbility* InAbility, const FEzAbilityParameter& Parameter, FText& OutText);
-	// EAbilityRunStatus Tick(float DeltaTime);
-	// EAbilityRunStatus Stop();
-	//
+	EAbilityRunStatus Start(UEzAbility* InAbility, const struct FEzAbilityParameter& Parameter, FText& OutText);
 	EAbilityRunStatus GetAbilityRunStatus() const;
+
+protected:
+	void Reset();
+	
 protected:
 	UPROPERTY(Transient)
-	TObjectPtr<UEzAbility>				Ability;
+	TObjectPtr<UEzAbilityComponent>	AbilityComponent;
 	
 	UPROPERTY(Transient)
-	TWeakObjectPtr<UEzAbilityComponent>	AbilityComponent;
-
+	TObjectPtr<UEzAbility>			Ability;
+	
 	UPROPERTY(Transient)
-	TWeakObjectPtr<AActor>				OwnerActor;
+	TObjectPtr<AActor>				OwnerActor;
 
 	UPROPERTY(Transient)
-	TWeakObjectPtr<APlayerController>	PlayerController;
+	TObjectPtr<APlayerController>	PlayerController;
 
 	UPROPERTY(Transient)
-	TWeakObjectPtr<AActor>				Instigator;
+	TObjectPtr<AActor>				Instigator;
 
 	UPROPERTY(Transient)
-	TArray<TWeakObjectPtr<AActor>>		TargetActors;
+	FEzAbilityTarget				Target;
 };

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

@@ -0,0 +1,151 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "EzAbilityTypes.h"
+#include "InstancedStructContainer.h"
+#include "UObject/Object.h"
+#include "EzAbilityInstanceData.generated.h"
+
+USTRUCT()
+struct EZABILITY_API FEzAbilityInstanceObjectWrapper
+{
+	GENERATED_BODY()
+
+	FEzAbilityInstanceObjectWrapper() = default;
+	FEzAbilityInstanceObjectWrapper(UObject* Object) : InstanceObject(Object) {}
+	
+	UPROPERTY()
+	TObjectPtr<UObject> InstanceObject = nullptr;
+};
+
+USTRUCT()
+struct EZABILITY_API FEzAbilityTemporaryInstanceData
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	TObjectPtr<const UEzAbility> Ability = nullptr;
+
+	// UPROPERTY()
+	// FStateTreeStateHandle RootState = FStateTreeStateHandle::Invalid;
+	//
+	// UPROPERTY()
+	// FStateTreeDataHandle DataHandle = FStateTreeDataHandle::Invalid;
+	//
+	// UPROPERTY()
+	// FStateTreeIndex16 OwnerNodeIndex = FStateTreeIndex16::Invalid; 
+	
+	UPROPERTY()
+	FInstancedStruct Instance;
+};
+
+USTRUCT()
+struct EZABILITY_API FEzAbilityInstanceStorage
+{
+	GENERATED_BODY()
+
+	friend struct FEzAbilityInstanceData;
+public:
+
+	void Reset();
+	
+	const	FEzAbilityExecutionState& GetExecutionState()			const	{ return ExecutionState; }
+			FEzAbilityExecutionState& GetMutableExecutionState()			{ return ExecutionState; }
+	
+	FConstStructView	GetStruct		(const int32 Index) const	{ return InstanceStructs[Index]; }
+	FStructView			GetMutableStruct(const int32 Index)			{ return InstanceStructs[Index]; }
+	const	UObject*	GetObject		(const int32 Index) const;
+			UObject*	GetMutableObject(const int32 Index) const;
+	
+	bool	IsObject	(const int32 Index) const { return InstanceStructs[Index].GetScriptStruct() == TBaseStructure<FEzAbilityInstanceObjectWrapper>::Get(); }
+	bool	IsValidIndex(const int32 Index) const { return InstanceStructs.IsValidIndex(Index); }
+	int32	Num()							const { return InstanceStructs.Num(); }
+
+	bool AreAllInstancesValid() const;
+	void ResetTemporaryInstances();
+	
+	TArrayView<FEzAbilityTemporaryInstanceData> GetMutableTemporaryInstances() { return TemporaryInstances; }
+
+	
+protected:
+	UPROPERTY()
+	FEzAbilityExecutionState				ExecutionState;
+
+	UPROPERTY()
+	FInstancedStructContainer				InstanceStructs;
+
+	UPROPERTY()
+	TArray<FEzAbilityTemporaryInstanceData> TemporaryInstances;
+
+	//event
+	//transitions
+	//global parameters
+};
+
+/**
+ * 
+ */
+USTRUCT()
+struct EZABILITY_API FEzAbilityInstanceData
+{
+	GENERATED_BODY()
+public:
+	FEzAbilityInstanceData() = default;
+	FEzAbilityInstanceData(const FEzAbilityInstanceData& Other);
+	FEzAbilityInstanceData(FEzAbilityInstanceData&& Other);
+	~FEzAbilityInstanceData();
+
+	FEzAbilityInstanceData& operator=(const FEzAbilityInstanceData& Other);
+	FEzAbilityInstanceData& operator=(FEzAbilityInstanceData&& Other);
+
+	void Reset();
+
+			FEzAbilityInstanceStorage&			GetMutableStorage()		const	{ return *InstanceStorage; }
+	const	FEzAbilityInstanceStorage&			GetStorage()			const	{ return *InstanceStorage; }
+	TWeakPtr<FEzAbilityInstanceStorage>			GetWeakMutableStorage()	const	{ return InstanceStorage; }
+	TWeakPtr<const FEzAbilityInstanceStorage>	GetWeakStorage()		const	{ return InstanceStorage;}
+	
+	void Init	(UObject& InOwner, TConstArrayView<FInstancedStruct> InStructs);
+	void Init	(UObject& InOwner, TConstArrayView<FConstStructView> InStructs);
+	void Append	(UObject& InOwner, TConstArrayView<FInstancedStruct> InStructs) const;
+	void Append	(UObject& InOwner, TConstArrayView<FConstStructView> InStructs) const;
+	void Append	(UObject& InOwner, TConstArrayView<FConstStructView> InStructs, TConstArrayView<FInstancedStruct*> InInstancesToMove) const;
+	
+	void	ShrinkTo(const int32 Num) const;
+	void	CopyFrom(UObject& InOwner, const FEzAbilityInstanceData& InOther) const;
+	bool	AreAllInstancesValid() const;
+	int32	GetEstimatedMemoryUsage() const;
+	bool	Identical(const FEzAbilityInstanceData* Other, uint32 PortFlags) const;
+	void	AddStructReferencedObjects(FReferenceCollector& Collector);
+	bool	Serialize(FArchive& Ar);
+	void	GetPreloadDependencies(TArray<UObject*>& OutDeps);
+	
+	int32	Num()							const { return GetStorage().Num(); }
+	bool	IsValidIndex(const int32 Index) const { return GetStorage().IsValidIndex(Index); }
+	bool	IsObject(const int32 Index)		const { return GetStorage().IsObject(Index); }
+	
+	FStructView			GetMutableStruct	(const int32 Index) const { return GetMutableStorage().GetMutableStruct(Index); }
+	FConstStructView	GetStruct			(const int32 Index) const { return GetStorage().GetStruct(Index); }
+			UObject*	GetMutableObject	(const int32 Index) const { return GetMutableStorage().GetMutableObject(Index); }
+	const	UObject*	GetObject			(const int32 Index) const { return GetStorage().GetObject(Index); }
+	
+	const	FEzAbilityExecutionState* GetExecutionState()			const { return &GetStorage().GetExecutionState(); }
+			FEzAbilityExecutionState* GetMutableExecutionState()	const { return &GetMutableStorage().GetMutableExecutionState(); }
+
+protected:
+	TSharedRef<FEzAbilityInstanceStorage> InstanceStorage = MakeShared<FEzAbilityInstanceStorage>();
+};
+
+template<>
+struct TStructOpsTypeTraits<FEzAbilityInstanceData> : public TStructOpsTypeTraitsBase2<FEzAbilityInstanceData>
+{
+	enum
+	{
+		WithIdentical = true,
+		WithAddStructReferencedObjects = true,
+		WithSerializer = true,
+		WithGetPreloadDependencies = true,
+	};
+};

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

@@ -16,6 +16,17 @@ enum class EAbilityRunStatus : uint8
 	Unset,
 };
 
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+///Frame
+USTRUCT()
+struct EZABILITY_API FEzAbilityFrame
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	TObjectPtr<class UEzAbility> Ability = nullptr;
+};
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 ///Slice
 UENUM()
@@ -125,3 +136,14 @@ struct EZABILITY_API FCompactEzAbilityTransition
 	UPROPERTY()
 	FEzAbilitySliceHandle State = FEzAbilitySliceHandle::Invalid;
 };
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+///Exe
+USTRUCT()
+struct EZABILITY_API FEzAbilityExecutionState
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	TArray<FEzAbilityFrame> ActiveFrames;
+};