ab

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

@@ -3,6 +3,7 @@
 
 #include "EzAbilityContext.h"
 
+#include "EzAbility.h"
 #include "EzAbilityComponent.h"
 #include "EzAbilityTypes.h"
 
@@ -29,6 +30,9 @@ void FEzAbilityContext::InitContext(UEzAbilityComponent* Component)
 		
 		TestActor = TestActor->GetOwner();
 	}
+
+	InstanceDataStorage = &InstanceData.GetMutableStorage();
+	check(InstanceDataStorage);
 }
 
 bool FEzAbilityContext::IsLocallyControlled() const
@@ -62,8 +66,44 @@ bool FEzAbilityContext::IsNetAuthority() const
 	return false;
 }
 
+bool FEzAbilityContext::IsValid() const
+{
+	return OwnerActor != nullptr && AbilityComponent != nullptr;
+}
+
+bool FEzAbilityContext::SetGlobalParameters(const FInstancedPropertyBag& Parameters) const
+{
+	if (ensureMsgf(Ability->GetDefaultParameters().GetPropertyBagStruct() == Parameters.GetPropertyBagStruct(),
+		TEXT("Parameters must be of the same struct type. Make sure to migrate the provided parameters to the same type as the StateTree default parameters.")))
+	{
+		InstanceDataStorage->SetGlobalParameters(Parameters);
+		return true;
+	}
+
+	return false;
+}
+
+FEzAbilityExecutionState& FEzAbilityContext::GetExecState()
+{
+	check(InstanceDataStorage);
+	return InstanceDataStorage->GetMutableExecutionState();
+}
+
+const FEzAbilityExecutionState& FEzAbilityContext::GetExecState() const
+{
+	check(InstanceDataStorage);
+	return InstanceDataStorage->GetExecutionState();
+}
+
 EAbilityRunStatus FEzAbilityContext::Start(UEzAbility* InAbility, const FEzAbilityParameter& Parameter, FText& OutText)
 {
+	if(!IsValid())
+	{
+		return EAbilityRunStatus::Failed;
+	}
+	
+	FEzAbilityExecutionState& State = GetExecState();
+	
 	if(Ability != nullptr)
 	{
 		//TODO 打断技能
@@ -76,7 +116,15 @@ EAbilityRunStatus FEzAbilityContext::Start(UEzAbility* InAbility, const FEzAbili
 	Target.DefaultLocations		= Parameter.Locations;
 	Target.DefaultTargets		= Parameter.Targets;
 
+	SetGlobalParameters(Ability->GetDefaultParameters());
+	
+	FEzAbilityFrame InitFrame = State.ActiveFrames.AddDefaulted_GetRef();
+	InitFrame.Ability			= Ability;
+	InitFrame.bIsGlobalFrame	= true;
+	InitFrame.RootState			= FEzAbilityStateHandle::Root;
 
+	UpdateInstanceData({}, State.ActiveFrames);
+	
 	//TODO 设置默认参数
 	//TODO 设置InstanceData
 	
@@ -103,4 +151,61 @@ void FEzAbilityContext::Reset()
 {
 	Instigator = nullptr;
 	Target.Reset();
+
+	InstanceData.Reset();
+}
+
+void FEzAbilityContext::UpdateInstanceData(TConstArrayView<FEzAbilityFrame> CurrentActiveFrames, TArrayView<FEzAbilityFrame> NextActiveFrames)
+{
+	int32 EstimatedNumStructs = 0;
+	for (FEzAbilityFrame& Frame : NextActiveFrames)
+	{
+		if(Frame.bIsGlobalFrame)
+		{
+			EstimatedNumStructs += Frame.Ability->NumGlobalInstanceData;
+		}
+		
+	}
+
+	TArray<FConstStructView, TConcurrentLinearArrayAllocator<FDefaultBlockAllocationTag>> InstanceStructs;
+	InstanceStructs.Reserve(EstimatedNumStructs);
+
+	TArray<FInstancedStruct*, TConcurrentLinearArrayAllocator<FDefaultBlockAllocationTag>> TempInstanceStructs;
+	TempInstanceStructs.Reserve(EstimatedNumStructs);
+
+	TArrayView<FEzAbilityTemporaryInstanceData> TempInstances = InstanceDataStorage->GetMutableTemporaryInstances();
+
+	int32 CurrentGlobalInstanceIndexBase = 0;
+	int32 NumCommonInstanceData = 0;
+
+	for (int32 FrameIndex = 0; FrameIndex < NextActiveFrames.Num(); FrameIndex++)
+	{
+		
+	}
+	
+	for (int32 Index = 0; Index < NumCommonInstanceData; Index++)
+	{
+		check(Index < InstanceData.Num());
+
+		FConstStructView ExistingInstanceDataView = InstanceData.GetStruct(Index);
+		FConstStructView NewInstanceDataView = InstanceStructs[Index]; 
+
+		check(NewInstanceDataView.GetScriptStruct() == ExistingInstanceDataView.GetScriptStruct());
+
+		const FEzAbilityInstanceObjectWrapper* ExistingWrapper = ExistingInstanceDataView.GetPtr<const FEzAbilityInstanceObjectWrapper>();
+		const FEzAbilityInstanceObjectWrapper* NewWrapper = ExistingInstanceDataView.GetPtr<const FEzAbilityInstanceObjectWrapper>();
+		if (ExistingWrapper && NewWrapper)
+		{
+			check(ExistingWrapper->InstanceObject && NewWrapper->InstanceObject);
+			check(ExistingWrapper->InstanceObject->GetClass() == NewWrapper->InstanceObject->GetClass());
+		}
+	}
+	
+	InstanceData.ShrinkTo(NumCommonInstanceData);
+	
+	InstanceData.Append(*OwnerActor,
+		MakeArrayView(InstanceStructs.GetData() + NumCommonInstanceData, InstanceStructs.Num() - NumCommonInstanceData),
+		MakeArrayView(TempInstanceStructs.GetData() + NumCommonInstanceData, TempInstanceStructs.Num() - NumCommonInstanceData));
+	
+	InstanceData.ResetTemporaryInstances();
 }

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

@@ -112,6 +112,11 @@ void FEzAbilityInstanceStorage::ResetTemporaryInstances()
 	TemporaryInstances.Reset();
 }
 
+void FEzAbilityInstanceStorage::SetGlobalParameters(const FInstancedPropertyBag& Parameters)
+{
+	GlobalParameters = Parameters;
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 ///InstanceData
 

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

@@ -3,13 +3,13 @@
 
 #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);
+const FEzAbilityStateHandle FEzAbilityStateHandle::Invalid		= FEzAbilityStateHandle();
+const FEzAbilityStateHandle FEzAbilityStateHandle::Succeeded	= FEzAbilityStateHandle(SucceededIndex);
+const FEzAbilityStateHandle FEzAbilityStateHandle::Failed		= FEzAbilityStateHandle(FailedIndex);
+const FEzAbilityStateHandle FEzAbilityStateHandle::Stopped		= FEzAbilityStateHandle(StoppedIndex);
+const FEzAbilityStateHandle FEzAbilityStateHandle::Root			= FEzAbilityStateHandle(0);
 
-EAbilityRunStatus FEzAbilitySliceHandle::ToCompletionStatus() const
+EAbilityRunStatus FEzAbilityStateHandle::ToCompletionStatus() const
 {
 	if (Index == SucceededIndex)
 	{
@@ -29,7 +29,7 @@ EAbilityRunStatus FEzAbilitySliceHandle::ToCompletionStatus() const
 	return EAbilityRunStatus::Unset;
 }
 
-FEzAbilitySliceHandle FEzAbilitySliceHandle::FromCompletionStatus(const EAbilityRunStatus Status)
+FEzAbilityStateHandle FEzAbilityStateHandle::FromCompletionStatus(const EAbilityRunStatus Status)
 {
 	switch (Status) {
 	case EAbilityRunStatus::Failed:		return Failed;
@@ -41,7 +41,7 @@ FEzAbilitySliceHandle FEzAbilitySliceHandle::FromCompletionStatus(const EAbility
 	return {};
 }
 
-FCompactEzAbilitySlice::FCompactEzAbilitySlice()
+FCompactEzAbilityState::FCompactEzAbilityState()
 	: StartTime(0), EndTime(0)
 {
 }
@@ -49,3 +49,7 @@ FCompactEzAbilitySlice::FCompactEzAbilitySlice()
 FCompactEzAbilityTransition::FCompactEzAbilityTransition()
 {
 }
+
+void FEzAbilityExecutionState::Reset()
+{
+}

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

@@ -3,8 +3,10 @@
 #pragma once
 
 #include "CoreMinimal.h"
+#include "EzAbilityInstanceData.h"
 #include "InstancedStructContainer.h"
 #include "EzAbilityTypes.h"
+#include "StructUtils/PropertyBag.h"
 #include "EzAbility.generated.h"
 
 struct FEzAbilityContext;
@@ -21,6 +23,8 @@ public:
 	virtual bool CanActivateAbility(FEzAbilityContext& Context, FText& OutText) const;
 	virtual bool ShouldReplicate(const FEzAbilityInstance& Instance) const;
 
+	const FInstancedPropertyBag& GetDefaultParameters() const { return Parameters; }
+	
 protected:
 	UFUNCTION(BlueprintNativeEvent)
 	bool K2_ActivateAbility(FEzAbilityContext& Context) const;
@@ -28,17 +32,29 @@ protected:
 	UFUNCTION(BlueprintNativeEvent)
 	bool K2_CanActivateAbility(FEzAbilityContext& Context, FText& OutText) const;
 	
-protected:
+public:
 
 	//Slices
 	UPROPERTY()
-	TArray<FCompactEzAbilitySlice>		Slices;
-
+	TArray<FCompactEzAbilityState>		Slices;
+	
+	//Transitions
+	UPROPERTY()
+	TArray<FCompactEzAbilityTransition> Transitions;
+	
 	//Condition, Evaluator, Task
 	UPROPERTY()
 	FInstancedStructContainer			Nodes;
 
-	//Transitions
 	UPROPERTY()
-	TArray<FCompactEzAbilityTransition> Transitions;
+	FEzAbilityInstanceData				DefaultInstanceData;
+	
+	UPROPERTY()
+	FEzAbilityInstanceData				SharedInstanceData;
+
+	UPROPERTY()
+	FInstancedPropertyBag				Parameters;
+
+	UPROPERTY()
+	uint16 NumGlobalInstanceData = 0;
 };

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

@@ -3,6 +3,7 @@
 #pragma once
 
 #include "CoreMinimal.h"
+#include "EzAbilityInstanceData.h"
 #include "UObject/Object.h"
 #include "EzAbilityTypes.h"
 #include "EzAbilityContext.generated.h"
@@ -47,14 +48,29 @@ public:
 	void InitContext(UEzAbilityComponent* Component);
 	bool IsLocallyControlled() const;
 	bool IsNetAuthority() const;
+	bool IsValid() const;
+	bool SetGlobalParameters(const FInstancedPropertyBag& Parameters) const;
+	
+	const	FEzAbilityInstanceData* GetInstanceData()			const	{ return &InstanceData; }
+			FEzAbilityInstanceData* GetMutableInstanceData()			{ return &InstanceData; }
+
+	const	FEzAbilityExecutionState& GetExecState() const;
+			FEzAbilityExecutionState& GetExecState();
 	
 	EAbilityRunStatus Start(UEzAbility* InAbility, const struct FEzAbilityParameter& Parameter, FText& OutText);
 	EAbilityRunStatus GetAbilityRunStatus() const;
 
 protected:
 	void Reset();
+
+	void UpdateInstanceData(TConstArrayView<FEzAbilityFrame> CurrentActiveFrames, TArrayView<FEzAbilityFrame> NextActiveFrames);
 	
 protected:
+	UPROPERTY(Transient)
+	FEzAbilityInstanceData			InstanceData;
+
+	FEzAbilityInstanceStorage*		InstanceDataStorage = nullptr;
+	
 	UPROPERTY(Transient)
 	TObjectPtr<UEzAbilityComponent>	AbilityComponent;
 	

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

@@ -5,6 +5,7 @@
 #include "CoreMinimal.h"
 #include "EzAbilityTypes.h"
 #include "InstancedStructContainer.h"
+#include "StructUtils/PropertyBag.h"
 #include "UObject/Object.h"
 #include "EzAbilityInstanceData.generated.h"
 
@@ -67,8 +68,10 @@ public:
 	void ResetTemporaryInstances();
 	
 	TArrayView<FEzAbilityTemporaryInstanceData> GetMutableTemporaryInstances() { return TemporaryInstances; }
-
 	
+	void				SetGlobalParameters(const FInstancedPropertyBag& Parameters);
+	FConstStructView	GetGlobalParameters()			const	{ return GlobalParameters.GetValue(); }
+	FStructView			GetMutableGlobalParameters()			{ return GlobalParameters.GetMutableValue(); }
 protected:
 	UPROPERTY()
 	FEzAbilityExecutionState				ExecutionState;
@@ -79,9 +82,12 @@ protected:
 	UPROPERTY()
 	TArray<FEzAbilityTemporaryInstanceData> TemporaryInstances;
 
+	UPROPERTY(Transient)
+	FInstancedPropertyBag					GlobalParameters;
+	
 	//event
 	//transitions
-	//global parameters
+
 };
 
 /**
@@ -134,6 +140,9 @@ public:
 	const	FEzAbilityExecutionState* GetExecutionState()			const { return &GetStorage().GetExecutionState(); }
 			FEzAbilityExecutionState* GetMutableExecutionState()	const { return &GetMutableStorage().GetMutableExecutionState(); }
 
+	void ResetTemporaryInstances() const { return GetMutableStorage().ResetTemporaryInstances(); }
+
+	
 protected:
 	TSharedRef<FEzAbilityInstanceStorage> InstanceStorage = MakeShared<FEzAbilityInstanceStorage>();
 };

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

@@ -16,17 +16,6 @@ enum class EAbilityRunStatus : uint8
 	Unset,
 };
 
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-///Frame
-USTRUCT()
-struct EZABILITY_API FEzAbilityFrame
-{
-	GENERATED_BODY()
-
-	UPROPERTY()
-	TObjectPtr<class UEzAbility> Ability = nullptr;
-};
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 ///Slice
 UENUM()
@@ -37,7 +26,7 @@ enum class ESliceType
 };
 
 USTRUCT(BlueprintType)
-struct EZABILITY_API FEzAbilitySliceHandle
+struct EZABILITY_API FEzAbilityStateHandle
 {
 	GENERATED_BODY()
 
@@ -46,18 +35,18 @@ struct EZABILITY_API FEzAbilitySliceHandle
 	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 const FEzAbilityStateHandle Invalid;
+	static const FEzAbilityStateHandle Succeeded;
+	static const FEzAbilityStateHandle Failed;
+	static const FEzAbilityStateHandle Stopped;
+	static const FEzAbilityStateHandle 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); }
+	friend FORCEINLINE uint32 GetTypeHash(const FEzAbilityStateHandle& Handle) { return GetTypeHash(Handle.Index); }
 
-	FEzAbilitySliceHandle() = default;
-	explicit FEzAbilitySliceHandle(const uint16 InIndex) : Index(InIndex) {}
-	explicit FEzAbilitySliceHandle(const int32 InIndex) : Index()
+	FEzAbilityStateHandle() = default;
+	explicit FEzAbilityStateHandle(const uint16 InIndex) : Index(InIndex) {}
+	explicit FEzAbilityStateHandle(const int32 InIndex) : Index()
 	{
 		check(InIndex == INDEX_NONE || IsValidIndex(InIndex));
 		Index = InIndex == INDEX_NONE ? InvalidIndex : static_cast<uint16>(InIndex);	
@@ -67,8 +56,8 @@ struct EZABILITY_API FEzAbilitySliceHandle
 	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; }
+	bool operator==(const FEzAbilityStateHandle& RHS) const { return Index == RHS.Index; }
+	bool operator!=(const FEzAbilityStateHandle& RHS) const { return Index != RHS.Index; }
 	
 	FString Describe() const
 	{
@@ -83,18 +72,18 @@ struct EZABILITY_API FEzAbilitySliceHandle
 	}
 
 	EAbilityRunStatus ToCompletionStatus() const;
-	static FEzAbilitySliceHandle FromCompletionStatus(const EAbilityRunStatus Status);
+	static FEzAbilityStateHandle FromCompletionStatus(const EAbilityRunStatus Status);
 	
 	UPROPERTY()
 	uint16 Index = InvalidIndex;
 };
 
 USTRUCT()
-struct EZABILITY_API FCompactEzAbilitySlice
+struct EZABILITY_API FCompactEzAbilityState
 {
 	GENERATED_BODY()
 
-	FCompactEzAbilitySlice();
+	FCompactEzAbilityState();
 
 	uint16	GetNextIndex()	const { return ChildrenEnd; };
 	bool	HasChildren()	const { return ChildrenEnd > ChildrenBegin; };
@@ -109,7 +98,7 @@ struct EZABILITY_API FCompactEzAbilitySlice
 	FName Name;
 
 	UPROPERTY()
-	FEzAbilitySliceHandle Parent = FEzAbilitySliceHandle::Invalid;
+	FEzAbilityStateHandle Parent = FEzAbilityStateHandle::Invalid;
 	
 	UPROPERTY()
 	float	StartTime;
@@ -134,7 +123,24 @@ struct EZABILITY_API FCompactEzAbilityTransition
 	FCompactEzAbilityTransition();
 	
 	UPROPERTY()
-	FEzAbilitySliceHandle State = FEzAbilitySliceHandle::Invalid;
+	FEzAbilityStateHandle State = FEzAbilityStateHandle::Invalid;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+///Frame
+USTRUCT()
+struct EZABILITY_API FEzAbilityFrame
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	TObjectPtr<class UEzAbility> Ability = nullptr;
+
+	UPROPERTY()
+	uint8 bIsGlobalFrame : 1 = false;
+
+	UPROPERTY()
+	FEzAbilityStateHandle RootState = FEzAbilityStateHandle::Root; 
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -146,4 +152,6 @@ struct EZABILITY_API FEzAbilityExecutionState
 
 	UPROPERTY()
 	TArray<FEzAbilityFrame> ActiveFrames;
+
+	void Reset();
 };