Flow asset params improvements

Source/Flow/Private/Asset/FlowAssetParams.cpp

@@ -367,12 +367,12 @@ void UFlowAssetParams::RebuildPropertiesMap()
 }
 #endif
 
-bool UFlowAssetParams::CanSupplyDataPinValues_Implementation() const
+bool UFlowAssetParams::CanSupplyDataPinValues() const
 {
 	return !PropertyMap.IsEmpty();
 }
 
-FFlowDataPinResult UFlowAssetParams::TrySupplyDataPin_Implementation(FName PinName) const
+FFlowDataPinResult UFlowAssetParams::TrySupplyDataPin(FName PinName) const
 {
 	if (const TInstancedStruct<FFlowDataPinValue>* Found = PropertyMap.Find(PinName))
 	{

Source/Flow/Private/Asset/FlowAssetParamsUtils.cpp

@@ -6,6 +6,20 @@
 #include "Misc/DateTime.h"
 #include "HAL/FileManager.h"
 
+#if WITH_EDITOR
+#include "Asset/FlowAssetParams.h"
+#include "FlowLogChannels.h"
+
+#include "AssetRegistry/AssetRegistryModule.h"
+#include "AssetToolsModule.h"
+#include "ContentBrowserModule.h"
+#include "FileHelpers.h"
+#include "IContentBrowserSingleton.h"
+#include "Misc/MessageDialog.h"
+#include "Modules/ModuleManager.h"
+#include "SourceControlHelpers.h"
+#endif
+
 #include UE_INLINE_GENERATED_CPP_BY_NAME(FlowAssetParamsUtils)
 
 #if WITH_EDITOR
@@ -116,4 +130,130 @@ bool FFlowAssetParamsUtils::ArePropertiesEqual(
 	return A.DataPinValue == B.DataPinValue;
 }
 
-#endif
+UFlowAssetParams* FFlowAssetParamsUtils::CreateChildParamsAsset(UFlowAssetParams& ParentParams, const bool bShowDialogs, FText* OutOptionalFailureReason)
+{
+	if (!IsValid(&ParentParams))
+	{
+		FailCreateChild(
+			NSLOCTEXT("FlowAssetParamsUtils", "InvalidParent", "Invalid Parent Flow Asset Params."),
+			bShowDialogs,
+			OutOptionalFailureReason);
+
+		return nullptr;
+	}
+
+	const FAssetToolsModule& AssetToolsModule = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools");
+
+	const FString PackagePath = FPackageName::GetLongPackagePath(ParentParams.GetPackage()->GetPathName());
+	const FString BaseAssetName = ParentParams.GetName();
+
+	// Generate a unique name for the new asset params
+	FString UniquePackageName;
+	FString UniqueAssetName;
+	AssetToolsModule.Get().CreateUniqueAssetName(PackagePath + TEXT("/") + BaseAssetName, TEXT(""), UniquePackageName, UniqueAssetName);
+
+	if (UniqueAssetName.IsEmpty())
+	{
+		FailCreateChild(
+			FText::Format(
+				NSLOCTEXT("FlowAssetParamsUtils", "UniqueNameFail", "Failed to generate unique asset name for child params of {0}."),
+				FText::FromString(BaseAssetName)),
+			bShowDialogs,
+			OutOptionalFailureReason);
+
+		return nullptr;
+	}
+
+	// Create the new asset params
+	UFlowAssetParams* NewParams = Cast<UFlowAssetParams>(
+		AssetToolsModule.Get().CreateAsset(UniqueAssetName, PackagePath, ParentParams.GetClass(), nullptr));
+
+	if (!IsValid(NewParams))
+	{
+		FailCreateChild(
+			FText::Format(
+				NSLOCTEXT("FlowAssetParamsUtils", "CreateAssetFail", "Failed to create child Flow Asset Params: {0}."),
+				FText::FromString(UniqueAssetName)),
+			bShowDialogs,
+			OutOptionalFailureReason);
+
+		return nullptr;
+	}
+
+	// Best-effort source control integration (before save)
+	if (USourceControlHelpers::IsAvailable())
+	{
+		const FString FileName = USourceControlHelpers::PackageFilename(NewParams->GetPathName());
+		if (!USourceControlHelpers::CheckOutOrAddFile(FileName))
+		{
+			UE_LOG(LogFlow, Warning, TEXT("Failed to check out/add %s; saved in-memory only"), *NewParams->GetPathName());
+		}
+	}
+
+	// Configure from parent (copies OwnerFlowAsset + Properties, sets ParentParams, rebuilds PropertyMap, marks dirty)
+	NewParams->ConfigureFlowAssetParams(ParentParams.OwnerFlowAsset, &ParentParams, ParentParams.Properties);
+
+	// Reconcile (cycle detection, flattened inheritance, etc.)
+	const EFlowReconcilePropertiesResult ReconcileResult = NewParams->ReconcilePropertiesWithParentParams();
+	if (EFlowReconcilePropertiesResult_Classifiers::IsErrorResult(ReconcileResult))
+	{
+		FailCreateChild(
+			FText::Format(
+				NSLOCTEXT("FlowAssetParamsUtils", "ReconcileFail",
+					"Created asset but reconciliation failed.\n\nAsset: {0}\nError: {1}\n\nThe asset may be invalid and should be reviewed."),
+				FText::FromString(NewParams->GetPathName()),
+				UEnum::GetDisplayValueAsText(ReconcileResult)),
+			bShowDialogs,
+			OutOptionalFailureReason);
+
+		// Keep going: asset exists and may still be useful for debugging/fixing
+	}
+
+	// Save the package (force save even if not prompted)
+	{
+		UPackage* Package = NewParams->GetPackage();
+		TArray<UPackage*> PackagesToSave = { Package };
+
+		const bool bForceSave = true;
+		if (!UEditorLoadingAndSavingUtils::SavePackages(PackagesToSave, bForceSave))
+		{
+			FailCreateChild(
+				FText::Format(
+					NSLOCTEXT("FlowAssetParamsUtils", "SaveFail", "Failed to save child Flow Asset Params: {0}."),
+					FText::FromString(NewParams->GetPathName())),
+				bShowDialogs,
+				OutOptionalFailureReason);
+
+			// Still return the in-memory asset
+		}
+	}
+
+	// Register + sync to Content Browser
+	{
+		const FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
+		AssetRegistryModule.Get().AssetCreated(NewParams);
+
+		const FContentBrowserModule& ContentBrowserModule = FModuleManager::LoadModuleChecked<FContentBrowserModule>("ContentBrowser");
+		const TArray<UObject*> AssetsToSync = { NewParams };
+		ContentBrowserModule.Get().SyncBrowserToAssets(AssetsToSync, true);
+	}
+
+	return NewParams;
+}
+
+void FFlowAssetParamsUtils::FailCreateChild(const FText& Reason, const bool bShowDialogs, FText* OutOptionalFailureReason)
+{
+	if (OutOptionalFailureReason)
+	{
+		*OutOptionalFailureReason = Reason;
+	}
+
+	UE_LOG(LogFlow, Error, TEXT("%s"), *Reason.ToString());
+
+	if (bShowDialogs)
+	{
+		FMessageDialog::Open(EAppMsgType::Ok, Reason);
+	}
+}
+
+#endif

Source/Flow/Private/Asset/FlowDeferredTransitionScope.cpp

@@ -0,0 +1,32 @@
+// Copyright https://github.com/MothCocoon/FlowGraph/graphs/contributors
+
+#include "Asset/FlowDeferredTransitionScope.h"
+#include "FlowAsset.h"
+#include "Interfaces/FlowExecutionGate.h"
+
+void FFlowDeferredTransitionScope::EnqueueDeferredTrigger(const FFlowDeferredTriggerInput& Entry)
+{
+	check(bIsOpen);
+
+	DeferredTriggers.Add(Entry);
+}
+
+bool FFlowDeferredTransitionScope::TryFlushDeferredTriggers(UFlowAsset& OwningFlowAsset)
+{
+	// Ensure the scope is closed before beginning flushing
+	CloseScope();
+
+	// Remove and trigger each deferred trigger input
+	while (!DeferredTriggers.IsEmpty() && !FFlowExecutionGate::IsHalted())
+	{
+		const FFlowDeferredTriggerInput Entry = DeferredTriggers[0];
+		DeferredTriggers.RemoveAt(0, 1, EAllowShrinking::No);
+
+		OwningFlowAsset.TriggerInput(Entry.NodeGuid, Entry.PinName, Entry.FromPin);
+	}
+
+	check(DeferredTriggers.IsEmpty() || FFlowExecutionGate::IsHalted());
+
+	// Return true if everything flushed without being interrupted by an ExecutionGate
+	return DeferredTriggers.IsEmpty();
+}