ultimate-unreal-engine-mcp 0.1.8 → 0.1.10

package/dist/tools/editor/index.js

@@ -93,15 +93,96 @@ export function registerEditorTools(server, bridge) {
                 y: z.number().describe('Y coordinate in Unreal units (cm)'),
                 z: z.number().describe('Z coordinate in Unreal units (cm)'),
             }).describe('World-space location to spawn the actor at'),
+            label: z.string().optional().describe('Optional editor display label for the spawned actor'),
         }),
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
         },
     }, withKnownIssues('ue_spawn_actor', async (args) => {
+        const payload = { class_name: args.class_name, location: args.location };
+        if (args.label) {
+            payload['label'] = args.label;
+        }
         return sendOrDisconnect(_bridge, {
             type: 'actor.spawn',
-            payload: { class_name: args.class_name, location: args.location },
+            payload,
+        });
+    }));
+    // --------------------------------------------------------------------------
+    // ue_set_actor_property
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_set_actor_property', {
+        title: 'Set Actor Property',
+        description: '[requires_plugin] Set a UPROPERTY value on an actor by label. Supports bool, int, float, string, name, text, actor (reference by label), and asset (reference by path).',
+        inputSchema: z.object({
+            actor_label: z.string().describe('The editor label of the target actor'),
+            property_name: z.string().describe('The UPROPERTY name to set (e.g., RoomID, RoomDoor, DoorCurve)'),
+            value: z.union([z.string(), z.number(), z.boolean()]).describe('The value to set — string for name/text/actor label/asset path, number for int/float, boolean for bool'),
+            value_type: z.enum(['bool', 'int', 'float', 'string', 'name', 'text', 'actor', 'asset']).describe('Type of the value'),
+        }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+        },
+    }, withKnownIssues('ue_set_actor_property', async (args) => {
+        return sendOrDisconnect(_bridge, {
+            type: 'actor.setProperty',
+            payload: {
+                actor_label: args.actor_label,
+                property_name: args.property_name,
+                value: args.value,
+                value_type: args.value_type,
+            },
+        });
+    }));
+    // --------------------------------------------------------------------------
+    // ue_create_data_asset
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_create_data_asset', {
+        title: 'Create Data Asset',
+        description: '[requires_plugin] Create a UPrimaryDataAsset (or subclass) at the given path with reflection-set properties.',
+        inputSchema: z.object({
+            asset_path: z.string().describe('UE asset path, e.g. /Game/Data/DA_ValveHandle'),
+            class_name: z.string().describe('Asset class name, e.g. ItemDefinition'),
+            properties: z.record(z.object({
+                value: z.union([z.string(), z.number(), z.boolean()]).describe('Property value'),
+                type: z.enum(['name', 'text', 'int', 'byte', 'string']).describe('Property type for reflection'),
+            })).optional().describe('Map of property_name → {value, type} to set after creation'),
+        }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+        },
+    }, withKnownIssues('ue_create_data_asset', async (args) => {
+        const payload = { asset_path: args.asset_path, class_name: args.class_name };
+        if (args.properties) {
+            payload['properties'] = args.properties;
+        }
+        return sendOrDisconnect(_bridge, { type: 'asset.createDataAsset', payload });
+    }));
+    // --------------------------------------------------------------------------
+    // ue_create_curve
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_create_curve', {
+        title: 'Create Float Curve',
+        description: '[requires_plugin] Create a UCurveFloat asset with keyframes at the given path.',
+        inputSchema: z.object({
+            asset_path: z.string().describe('UE asset path, e.g. /Game/Curves/C_DoorSwing'),
+            keys: z.array(z.object({
+                time: z.number().describe('Key time in seconds'),
+                value: z.number().describe('Key value'),
+                interp: z.enum(['linear', 'cubic', 'constant']).optional().describe('Interpolation mode (default: cubic)'),
+            })).describe('Array of keyframes'),
+        }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+        },
+    }, withKnownIssues('ue_create_curve', async (args) => {
+        return sendOrDisconnect(_bridge, {
+            type: 'asset.createCurve',
+            payload: { asset_path: args.asset_path, keys: args.keys },
         });
     }));
     // --------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultimate-unreal-engine-mcp",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "MCP server giving AI assistants full access to Unreal Engine 5.7 projects",
   "type": "module",
   "engines": {

package/unreal-plugin/MCPBridge/Source/MCPBridgeEditor/Private/MCPActorCommands.cpp

@@ -201,6 +201,13 @@ void RegisterActorCommands(FMCPCommandRouter& Router)
 		const FVector   Location(X, Y, Z);
 		const FRotator  Rotation(0.0, 0.0, 0.0);
 
+		// Optional label — sets the editor display name after spawn.
+		FString Label;
+		if (Payload->TryGetStringField(TEXT("label"), Label) && !Label.IsEmpty())
+		{
+			Params.Name = FName(*Label);
+		}
+
 		AActor* Spawned = World->SpawnActor<AActor>(ActorClass, Location, Rotation, Params);
 		if (!Spawned)
 		{
@@ -208,6 +215,12 @@ void RegisterActorCommands(FMCPCommandRouter& Router)
 			return;
 		}
 
+		// Apply explicit label if provided (overrides auto-generated label).
+		if (!Label.IsEmpty())
+		{
+			Spawned->SetActorLabel(Label);
+		}
+
 		TSharedPtr<FJsonObject> Data = MakeShared<FJsonObject>();
 		Data->SetStringField(TEXT("label"), Spawned->GetActorLabel());
 		Data->SetStringField(TEXT("id"),    Spawned->GetName());
@@ -412,4 +425,187 @@ void RegisterActorCommands(FMCPCommandRouter& Router)
 
 		SendResponse(BuildActorSuccessResponse(CorrId, Data) + TEXT("\n"));
 	});
+
+	// -----------------------------------------------------------------------
+	// actor.setProperty
+	// Sets a UPROPERTY on an actor by label.  Supports:
+	//   - Primitive types: bool, int, float, FString, FName, FText
+	//   - Actor references: resolved by actor label in the current world
+	//   - Asset references: resolved by UE asset path (e.g. /Game/Data/DA_Key)
+	// Payload: { actor_label, property_name, value, value_type }
+	// value_type: "bool"|"int"|"float"|"string"|"name"|"text"|"actor"|"asset"
+	// -----------------------------------------------------------------------
+	Router.RegisterHandler(TEXT("actor.setProperty"), [](TSharedPtr<FJsonObject> Cmd, FMCPResponseSender SendResponse)
+	{
+		const FString CorrId = Cmd->GetStringField(TEXT("correlationId"));
+
+		TSharedPtr<FJsonObject> Payload;
+		const TSharedPtr<FJsonValue>* PayloadVal = Cmd->Values.Find(TEXT("payload"));
+		if (PayloadVal && (*PayloadVal)->Type == EJson::Object)
+		{
+			Payload = (*PayloadVal)->AsObject();
+		}
+
+		FString ActorLabel, PropertyName, ValueType;
+		if (!Payload.IsValid()
+			|| !Payload->TryGetStringField(TEXT("actor_label"), ActorLabel)  || ActorLabel.IsEmpty()
+			|| !Payload->TryGetStringField(TEXT("property_name"), PropertyName) || PropertyName.IsEmpty()
+			|| !Payload->TryGetStringField(TEXT("value_type"), ValueType) || ValueType.IsEmpty())
+		{
+			SendResponse(BuildActorErrorResponse(CorrId, TEXT("missing_required_fields")) + TEXT("\n"));
+			return;
+		}
+
+		UWorld* World = GEditor ? GEditor->GetEditorWorldContext().World() : nullptr;
+		if (!World)
+		{
+			SendResponse(BuildActorErrorResponse(CorrId, TEXT("no_world_open")) + TEXT("\n"));
+			return;
+		}
+
+		// Find target actor by label.
+		AActor* TargetActor = nullptr;
+		for (TActorIterator<AActor> It(World); It; ++It)
+		{
+			if ((*It)->GetActorLabel() == ActorLabel)
+			{
+				TargetActor = *It;
+				break;
+			}
+		}
+		if (!TargetActor)
+		{
+			SendResponse(BuildActorErrorResponse(CorrId, TEXT("actor_not_found")) + TEXT("\n"));
+			return;
+		}
+
+		// Find the UPROPERTY by name on the actor's class.
+		FProperty* Prop = TargetActor->GetClass()->FindPropertyByName(FName(*PropertyName));
+		if (!Prop)
+		{
+			SendResponse(BuildActorErrorResponse(CorrId, TEXT("property_not_found")) + TEXT("\n"));
+			return;
+		}
+
+		TargetActor->Modify();
+		void* ValuePtr = Prop->ContainerPtrToValuePtr<void>(TargetActor);
+
+		if (ValueType == TEXT("bool"))
+		{
+			bool bVal = false;
+			Payload->TryGetBoolField(TEXT("value"), bVal);
+			if (FBoolProperty* BoolProp = CastField<FBoolProperty>(Prop))
+			{
+				BoolProp->SetPropertyValue(ValuePtr, bVal);
+			}
+		}
+		else if (ValueType == TEXT("int"))
+		{
+			int32 IntVal = 0;
+			Payload->TryGetNumberField(TEXT("value"), *(double*)&IntVal);
+			double Dbl = 0;
+			Payload->TryGetNumberField(TEXT("value"), Dbl);
+			IntVal = static_cast<int32>(Dbl);
+			if (FIntProperty* IntProp = CastField<FIntProperty>(Prop))
+			{
+				IntProp->SetPropertyValue(ValuePtr, IntVal);
+			}
+		}
+		else if (ValueType == TEXT("float"))
+		{
+			double Dbl = 0.0;
+			Payload->TryGetNumberField(TEXT("value"), Dbl);
+			if (FFloatProperty* FloatProp = CastField<FFloatProperty>(Prop))
+			{
+				FloatProp->SetPropertyValue(ValuePtr, static_cast<float>(Dbl));
+			}
+			else if (FDoubleProperty* DoubleProp = CastField<FDoubleProperty>(Prop))
+			{
+				DoubleProp->SetPropertyValue(ValuePtr, Dbl);
+			}
+		}
+		else if (ValueType == TEXT("string"))
+		{
+			FString StrVal;
+			Payload->TryGetStringField(TEXT("value"), StrVal);
+			if (FStrProperty* StrProp = CastField<FStrProperty>(Prop))
+			{
+				StrProp->SetPropertyValue(ValuePtr, StrVal);
+			}
+		}
+		else if (ValueType == TEXT("name"))
+		{
+			FString StrVal;
+			Payload->TryGetStringField(TEXT("value"), StrVal);
+			if (FNameProperty* NameProp = CastField<FNameProperty>(Prop))
+			{
+				NameProp->SetPropertyValue(ValuePtr, FName(*StrVal));
+			}
+		}
+		else if (ValueType == TEXT("text"))
+		{
+			FString StrVal;
+			Payload->TryGetStringField(TEXT("value"), StrVal);
+			if (FTextProperty* TextProp = CastField<FTextProperty>(Prop))
+			{
+				TextProp->SetPropertyValue(ValuePtr, FText::FromString(StrVal));
+			}
+		}
+		else if (ValueType == TEXT("actor"))
+		{
+			// value is the label of another actor in the world.
+			FString RefLabel;
+			Payload->TryGetStringField(TEXT("value"), RefLabel);
+			AActor* RefActor = nullptr;
+			for (TActorIterator<AActor> It(World); It; ++It)
+			{
+				if ((*It)->GetActorLabel() == RefLabel)
+				{
+					RefActor = *It;
+					break;
+				}
+			}
+			FObjectProperty* ObjProp = CastField<FObjectProperty>(Prop);
+			if (ObjProp)
+			{
+				ObjProp->SetObjectPropertyValue(ValuePtr, RefActor);
+			}
+		}
+		else if (ValueType == TEXT("asset"))
+		{
+			// value is an asset path, e.g. /Game/Data/DA_ValveHandle
+			FString AssetPath;
+			Payload->TryGetStringField(TEXT("value"), AssetPath);
+			UObject* Asset = LoadObject<UObject>(nullptr, *AssetPath);
+			if (!Asset)
+			{
+				SendResponse(BuildActorErrorResponse(CorrId, TEXT("asset_not_found")) + TEXT("\n"));
+				return;
+			}
+			FObjectProperty* ObjProp = CastField<FObjectProperty>(Prop);
+			if (ObjProp)
+			{
+				ObjProp->SetObjectPropertyValue(ValuePtr, Asset);
+			}
+		}
+		else
+		{
+			SendResponse(BuildActorErrorResponse(CorrId, TEXT("unsupported_value_type")) + TEXT("\n"));
+			return;
+		}
+
+		// Mark level dirty.
+		if (TargetActor->GetLevel())
+		{
+			TargetActor->GetLevel()->MarkPackageDirty();
+		}
+
+		TSharedPtr<FJsonObject> Data = MakeShared<FJsonObject>();
+		Data->SetStringField(TEXT("label"), ActorLabel);
+		Data->SetStringField(TEXT("property"), PropertyName);
+		Data->SetStringField(TEXT("value_type"), ValueType);
+		Data->SetBoolField(TEXT("applied"), true);
+
+		SendResponse(BuildActorSuccessResponse(CorrId, Data) + TEXT("\n"));
+	});
 }

package/unreal-plugin/MCPBridge/Source/MCPBridgeEditor/Private/MCPActorCommands.h

@@ -1,6 +1,6 @@
 // MCPActorCommands.h
 // Declares the registration function for all actor-related MCP command handlers.
-// Handlers: actor.list, actor.spawn, actor.transform, actor.delete
+// Handlers: actor.list, actor.spawn, actor.transform, actor.delete, actor.setProperty
 //
 // Call RegisterActorCommands(*Router) in MCPBridgeSubsystem::Initialize()
 // BEFORE the TCP server starts accepting connections.
@@ -10,7 +10,7 @@
 #include "MCPCommandRouter.h"
 
 /**
- * Register all four actor command handlers into the given router.
+ * Register all actor command handlers into the given router.
  * Must be called on the game thread before connections arrive.
  */
 void RegisterActorCommands(FMCPCommandRouter& Router);

package/unreal-plugin/MCPBridge/Source/MCPBridgeEditor/Private/MCPAssetCommands.cpp

@@ -23,6 +23,12 @@
 #include "Serialization/JsonWriter.h"
 #include "Dom/JsonObject.h"
 #include "Dom/JsonValue.h"
+#include "AssetToolsModule.h"
+#include "IAssetTools.h"
+#include "Curves/CurveFloat.h"
+#include "Curves/RichCurve.h"
+#include "UObject/SavePackage.h"
+#include "UObject/Package.h"
 
 // ---------------------------------------------------------------------------
 // File-scope JSON response helpers (identical pattern to MCPCommandRouter.cpp)
@@ -287,4 +293,245 @@ void RegisterAssetCommands(FMCPCommandRouter& Router)
 
 		SendResponse(BuildSuccessResponse(CorrId, Data));
 	});
+
+	// -----------------------------------------------------------------------
+	// asset.createDataAsset
+	// Creates a UPrimaryDataAsset (or subclass) in /Game/.
+	// Payload: { asset_path, class_name, properties: { name: {value, type}, ... } }
+	// Properties are set via UE reflection after creation.
+	// -----------------------------------------------------------------------
+	Router.RegisterHandler(TEXT("asset.createDataAsset"), [](TSharedPtr<FJsonObject> Command, FMCPResponseSender SendResponse)
+	{
+		const FString CorrId = Command.IsValid() ? Command->GetStringField(TEXT("correlationId")) : TEXT("");
+
+		TSharedPtr<FJsonObject> Payload;
+		const TSharedPtr<FJsonValue>* PayloadVal = Command->Values.Find(TEXT("payload"));
+		if (PayloadVal && (*PayloadVal)->Type == EJson::Object)
+		{
+			Payload = (*PayloadVal)->AsObject();
+		}
+
+		FString AssetPath, ClassName;
+		if (!Payload.IsValid()
+			|| !Payload->TryGetStringField(TEXT("asset_path"), AssetPath)  || AssetPath.IsEmpty()
+			|| !Payload->TryGetStringField(TEXT("class_name"), ClassName)  || ClassName.IsEmpty())
+		{
+			SendResponse(BuildErrorResponse(CorrId, TEXT("missing_asset_path_or_class")));
+			return;
+		}
+
+		// Security: only allow /Game/ paths.
+		if (!AssetPath.StartsWith(TEXT("/Game/")))
+		{
+			SendResponse(BuildErrorResponse(CorrId, TEXT("path_must_start_with_/Game/")));
+			return;
+		}
+
+		// Resolve class by name.
+		UClass* AssetClass = FindFirstObject<UClass>(*ClassName);
+		if (!AssetClass)
+		{
+			AssetClass = FindFirstObject<UClass>(*(TEXT("U") + ClassName));
+		}
+		if (!AssetClass)
+		{
+			SendResponse(BuildErrorResponse(CorrId, TEXT("class_not_found")));
+			return;
+		}
+
+		// Split AssetPath into package path and asset name.
+		FString PackagePath, AssetName;
+		AssetPath.Split(TEXT("/"), &PackagePath, &AssetName, ESearchCase::IgnoreCase, ESearchDir::FromEnd);
+		if (PackagePath.IsEmpty() || AssetName.IsEmpty())
+		{
+			SendResponse(BuildErrorResponse(CorrId, TEXT("invalid_asset_path")));
+			return;
+		}
+
+		// Create package and the object inside it.
+		UPackage* Package = CreatePackage(*AssetPath);
+		if (!Package)
+		{
+			SendResponse(BuildErrorResponse(CorrId, TEXT("package_creation_failed")));
+			return;
+		}
+
+		UObject* NewAsset = NewObject<UObject>(Package, AssetClass, FName(*AssetName), RF_Public | RF_Standalone);
+		if (!NewAsset)
+		{
+			SendResponse(BuildErrorResponse(CorrId, TEXT("object_creation_failed")));
+			return;
+		}
+
+		// Apply properties via reflection.
+		const TSharedPtr<FJsonObject>* PropsObj;
+		if (Payload->TryGetObjectField(TEXT("properties"), PropsObj))
+		{
+			for (const auto& Pair : (*PropsObj)->Values)
+			{
+				FProperty* Prop = AssetClass->FindPropertyByName(FName(*Pair.Key));
+				if (!Prop) continue;
+
+				void* ValPtr = Prop->ContainerPtrToValuePtr<void>(NewAsset);
+				const TSharedPtr<FJsonObject>* PropDef;
+				if (!Pair.Value->TryGetObject(PropDef)) continue;
+
+				FString PropType;
+				(*PropDef)->TryGetStringField(TEXT("type"), PropType);
+
+				if (PropType == TEXT("name"))
+				{
+					FString Val; (*PropDef)->TryGetStringField(TEXT("value"), Val);
+					if (FNameProperty* NP = CastField<FNameProperty>(Prop)) NP->SetPropertyValue(ValPtr, FName(*Val));
+				}
+				else if (PropType == TEXT("text"))
+				{
+					FString Val; (*PropDef)->TryGetStringField(TEXT("value"), Val);
+					if (FTextProperty* TP = CastField<FTextProperty>(Prop)) TP->SetPropertyValue(ValPtr, FText::FromString(Val));
+				}
+				else if (PropType == TEXT("int"))
+				{
+					double Dbl = 0; (*PropDef)->TryGetNumberField(TEXT("value"), Dbl);
+					if (FIntProperty* IP = CastField<FIntProperty>(Prop)) IP->SetPropertyValue(ValPtr, static_cast<int32>(Dbl));
+				}
+				else if (PropType == TEXT("byte"))
+				{
+					// For UENUM(uint8) properties — set by numeric value.
+					double Dbl = 0; (*PropDef)->TryGetNumberField(TEXT("value"), Dbl);
+					if (FByteProperty* BP = CastField<FByteProperty>(Prop))
+					{
+						BP->SetPropertyValue(ValPtr, static_cast<uint8>(Dbl));
+					}
+					else if (FEnumProperty* EP = CastField<FEnumProperty>(Prop))
+					{
+						FNumericProperty* UnderlyingProp = EP->GetUnderlyingProperty();
+						if (UnderlyingProp)
+						{
+							UnderlyingProp->SetIntPropertyValue(ValPtr, static_cast<int64>(Dbl));
+						}
+					}
+				}
+				else if (PropType == TEXT("string"))
+				{
+					FString Val; (*PropDef)->TryGetStringField(TEXT("value"), Val);
+					if (FStrProperty* SP = CastField<FStrProperty>(Prop)) SP->SetPropertyValue(ValPtr, Val);
+				}
+			}
+		}
+
+		// Notify asset registry and save.
+		FAssetRegistryModule::AssetCreated(NewAsset);
+		NewAsset->MarkPackageDirty();
+		Package->SetDirtyFlag(true);
+
+		// Auto-save so the asset persists.
+		FString FilePath = FPackageName::LongPackageNameToFilename(AssetPath, FPackageName::GetAssetPackageExtension());
+		FSavePackageArgs SaveArgs;
+		SaveArgs.TopLevelFlags = RF_Public | RF_Standalone;
+		UPackage::SavePackage(Package, NewAsset, *FilePath, SaveArgs);
+
+		TSharedPtr<FJsonObject> Data = MakeShared<FJsonObject>();
+		Data->SetStringField(TEXT("path"), AssetPath);
+		Data->SetStringField(TEXT("class"), ClassName);
+		Data->SetBoolField(TEXT("created"), true);
+
+		SendResponse(BuildSuccessResponse(CorrId, Data));
+	});
+
+	// -----------------------------------------------------------------------
+	// asset.createCurve
+	// Creates a UCurveFloat asset with keyframes.
+	// Payload: { asset_path, keys: [ {time, value, interp?}, ... ] }
+	// interp: "linear"|"cubic"|"constant" (default: "cubic" for ease-in-out)
+	// -----------------------------------------------------------------------
+	Router.RegisterHandler(TEXT("asset.createCurve"), [](TSharedPtr<FJsonObject> Command, FMCPResponseSender SendResponse)
+	{
+		const FString CorrId = Command.IsValid() ? Command->GetStringField(TEXT("correlationId")) : TEXT("");
+
+		TSharedPtr<FJsonObject> Payload;
+		const TSharedPtr<FJsonValue>* PayloadVal = Command->Values.Find(TEXT("payload"));
+		if (PayloadVal && (*PayloadVal)->Type == EJson::Object)
+		{
+			Payload = (*PayloadVal)->AsObject();
+		}
+
+		FString AssetPath;
+		if (!Payload.IsValid() || !Payload->TryGetStringField(TEXT("asset_path"), AssetPath) || AssetPath.IsEmpty())
+		{
+			SendResponse(BuildErrorResponse(CorrId, TEXT("missing_asset_path")));
+			return;
+		}
+
+		if (!AssetPath.StartsWith(TEXT("/Game/")))
+		{
+			SendResponse(BuildErrorResponse(CorrId, TEXT("path_must_start_with_/Game/")));
+			return;
+		}
+
+		// Split path.
+		FString PackagePath, AssetName;
+		AssetPath.Split(TEXT("/"), &PackagePath, &AssetName, ESearchCase::IgnoreCase, ESearchDir::FromEnd);
+
+		UPackage* Package = CreatePackage(*AssetPath);
+		if (!Package)
+		{
+			SendResponse(BuildErrorResponse(CorrId, TEXT("package_creation_failed")));
+			return;
+		}
+
+		UCurveFloat* Curve = NewObject<UCurveFloat>(Package, FName(*AssetName), RF_Public | RF_Standalone);
+		if (!Curve)
+		{
+			SendResponse(BuildErrorResponse(CorrId, TEXT("curve_creation_failed")));
+			return;
+		}
+
+		// Add keyframes from the "keys" array.
+		const TArray<TSharedPtr<FJsonValue>>* KeysArray;
+		if (Payload->TryGetArrayField(TEXT("keys"), KeysArray))
+		{
+			FRichCurve& RichCurve = Curve->FloatCurve;
+			for (const auto& KeyVal : *KeysArray)
+			{
+				const TSharedPtr<FJsonObject>* KeyObj;
+				if (!KeyVal->TryGetObject(KeyObj)) continue;
+
+				double Time = 0.0, Value = 0.0;
+				(*KeyObj)->TryGetNumberField(TEXT("time"), Time);
+				(*KeyObj)->TryGetNumberField(TEXT("value"), Value);
+
+				FString Interp = TEXT("cubic");
+				(*KeyObj)->TryGetStringField(TEXT("interp"), Interp);
+
+				ERichCurveInterpMode InterpMode = RCIM_Cubic;
+				if (Interp == TEXT("linear"))   InterpMode = RCIM_Linear;
+				else if (Interp == TEXT("constant")) InterpMode = RCIM_Constant;
+
+				FKeyHandle Handle = RichCurve.AddKey(static_cast<float>(Time), static_cast<float>(Value));
+				RichCurve.SetKeyInterpMode(Handle, InterpMode);
+
+				if (InterpMode == RCIM_Cubic)
+				{
+					RichCurve.SetKeyTangentMode(Handle, RCTM_Auto);
+				}
+			}
+			RichCurve.AutoSetTangents();
+		}
+
+		FAssetRegistryModule::AssetCreated(Curve);
+		Curve->MarkPackageDirty();
+		Package->SetDirtyFlag(true);
+
+		FString FilePath = FPackageName::LongPackageNameToFilename(AssetPath, FPackageName::GetAssetPackageExtension());
+		FSavePackageArgs SaveArgs;
+		SaveArgs.TopLevelFlags = RF_Public | RF_Standalone;
+		UPackage::SavePackage(Package, Curve, *FilePath, SaveArgs);
+
+		TSharedPtr<FJsonObject> Data = MakeShared<FJsonObject>();
+		Data->SetStringField(TEXT("path"), AssetPath);
+		Data->SetNumberField(TEXT("key_count"), KeysArray ? KeysArray->Num() : 0);
+		Data->SetBoolField(TEXT("created"), true);
+
+		SendResponse(BuildSuccessResponse(CorrId, Data));
+	});
 }