flockbay 0.10.15 → 0.10.17

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Private/Commands/UnrealMCPBlueprintNodeCommands.cpp

@@ -16,6 +16,8 @@
 #include "Camera/CameraActor.h"
 #include "Kismet/GameplayStatics.h"
 #include "EdGraphSchema_K2.h"
+#include "UObject/UObjectIterator.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
 
 // Declare the log category
 DEFINE_LOG_CATEGORY_STATIC(LogUnrealMCP, Log, All);
@@ -34,6 +36,10 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleCommand(const FSt
     {
         return HandleAddBlueprintGetSelfComponentReference(Params);
     }
+    else if (CommandType == TEXT("add_blueprint_get_component_node"))
+    {
+        return HandleAddBlueprintGetComponentNode(Params);
+    }
     else if (CommandType == TEXT("add_blueprint_event_node"))
     {
         return HandleAddBlueprintEvent(Params);
@@ -58,10 +64,77 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleCommand(const FSt
     {
         return HandleFindBlueprintNodes(Params);
     }
+    else if (CommandType == TEXT("search_blueprint_functions"))
+    {
+        return HandleSearchBlueprintFunctions(Params);
+    }
+    else if (CommandType == TEXT("resolve_blueprint_function"))
+    {
+        return HandleResolveBlueprintFunction(Params);
+    }
     
     return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Unknown blueprint node command: %s"), *CommandType));
 }
 
+TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleAddBlueprintGetComponentNode(const TSharedPtr<FJsonObject>& Params)
+{
+    // This mirrors the editor UX of dragging a Blueprint component into the EventGraph,
+    // which creates a variable-get node referencing that component on Self.
+    FString BlueprintName;
+    if (!Params->TryGetStringField(TEXT("blueprint_name"), BlueprintName))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'blueprint_name' parameter"));
+    }
+
+    FString ComponentName;
+    if (!Params->TryGetStringField(TEXT("component_name"), ComponentName))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'component_name' parameter"));
+    }
+
+    FVector2D NodePosition(0.0f, 0.0f);
+    if (Params->HasField(TEXT("node_position")))
+    {
+        NodePosition = FUnrealMCPCommonUtils::GetVector2DFromJson(Params, TEXT("node_position"));
+    }
+
+    UBlueprint* Blueprint = FUnrealMCPCommonUtils::FindBlueprint(BlueprintName);
+    if (!Blueprint)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Blueprint not found: %s"), *BlueprintName));
+    }
+
+    UEdGraph* EventGraph = FUnrealMCPCommonUtils::FindOrCreateEventGraph(Blueprint);
+    if (!EventGraph)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to get event graph"));
+    }
+
+    UK2Node_VariableGet* GetComponentNode = NewObject<UK2Node_VariableGet>(EventGraph);
+    if (!GetComponentNode)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to create get component node"));
+    }
+
+    FMemberReference& VarRef = GetComponentNode->VariableReference;
+    VarRef.SetSelfMember(FName(*ComponentName));
+
+    GetComponentNode->NodePosX = NodePosition.X;
+    GetComponentNode->NodePosY = NodePosition.Y;
+
+    EventGraph->AddNode(GetComponentNode);
+    GetComponentNode->CreateNewGuid();
+    GetComponentNode->PostPlacedNewNode();
+    GetComponentNode->AllocateDefaultPins();
+    GetComponentNode->ReconstructNode();
+
+    FBlueprintEditorUtils::MarkBlueprintAsModified(Blueprint);
+
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetStringField(TEXT("node_id"), GetComponentNode->NodeGuid.ToString());
+    return ResultObj;
+}
+
 TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleConnectBlueprintNodes(const TSharedPtr<FJsonObject>& Params)
 {
     // Get required parameters
@@ -291,6 +364,11 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleAddBlueprintFunct
     FString Target;
     Params->TryGetStringField(TEXT("target"), Target);
 
+    FString OwnerPath;
+    Params->TryGetStringField(TEXT("function_owner_path"), OwnerPath);
+    Params->TryGetStringField(TEXT("owner_class_path"), OwnerPath);
+    Params->TryGetStringField(TEXT("ownerPath"), OwnerPath);
+
     // Find the blueprint
     UBlueprint* Blueprint = FUnrealMCPCommonUtils::FindBlueprint(BlueprintName);
     if (!Blueprint)
@@ -313,6 +391,21 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleAddBlueprintFunct
     UE_LOG(LogTemp, Display, TEXT("Looking for function '%s' in target '%s'"), 
            *FunctionName, Target.IsEmpty() ? TEXT("Blueprint") : *Target);
     
+    // If we have an explicit owner class path, resolve it first (most reliable across UE versions).
+    if (!OwnerPath.IsEmpty())
+    {
+        OwnerPath = OwnerPath.TrimStartAndEnd();
+        UClass* OwnerClass = LoadObject<UClass>(nullptr, *OwnerPath);
+        if (!OwnerClass && !OwnerPath.Contains(TEXT("'")))
+        {
+            OwnerClass = LoadObject<UClass>(nullptr, *FString::Printf(TEXT("Class'%s'"), *OwnerPath));
+        }
+        if (OwnerClass)
+        {
+            Function = OwnerClass->FindFunctionByName(*FunctionName);
+        }
+    }
+
     // Check if we have a target class specified
     if (!Target.IsEmpty())
     {
@@ -366,8 +459,8 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleAddBlueprintFunct
             }
         }
         
-        // If we found a target class, look for the function there
-        if (TargetClass)
+        // If we found a target class, look for the function there (unless owner path already resolved).
+        if (TargetClass && !Function)
         {
             UE_LOG(LogTemp, Display, TEXT("Looking for function '%s' in class '%s'"), 
                    *FunctionName, *TargetClass->GetName());
@@ -390,8 +483,6 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleAddBlueprintFunct
                     for (TFieldIterator<UFunction> FuncIt(CurrentClass); FuncIt; ++FuncIt)
                     {
                         UFunction* AvailableFunc = *FuncIt;
-                        UE_LOG(LogTemp, Display, TEXT("  - Available function: %s"), *AvailableFunc->GetName());
-                        
                         if (AvailableFunc->GetName().Equals(FunctionName, ESearchCase::IgnoreCase))
                         {
                             UE_LOG(LogTemp, Display, TEXT("  - Found case-insensitive match: %s"), *AvailableFunc->GetName());
@@ -670,6 +761,264 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleAddBlueprintFunct
     return ResultObj;
 }
 
+static bool IsBlueprintCallableFunction(UFunction* Function)
+{
+    if (!Function) return false;
+    const bool bCallable = Function->HasAnyFunctionFlags(FUNC_BlueprintCallable | FUNC_BlueprintPure);
+    if (!bCallable) return false;
+    if (Function->HasAnyFunctionFlags(FUNC_Delegate)) return false;
+    if (Function->HasMetaData(FName(TEXT("DeprecatedFunction")))) return false;
+    return true;
+}
+
+static FString SafeDisplayName(UFunction* Function)
+{
+    if (!Function) return TEXT("");
+    if (Function->HasMetaData(FName(TEXT("DisplayName"))))
+    {
+        return Function->GetMetaData(FName(TEXT("DisplayName")));
+    }
+    return Function->GetName();
+}
+
+static bool MatchesQuery(const FString& QueryLower, const FString& Candidate)
+{
+    return Candidate.ToLower().Contains(QueryLower);
+}
+
+static UClass* ResolveClassBestEffort(const FString& Target)
+{
+    FString T = Target.TrimStartAndEnd();
+    if (T.IsEmpty()) return nullptr;
+
+    if (T.StartsWith(TEXT("/Script/")))
+    {
+        return LoadObject<UClass>(nullptr, *T);
+    }
+
+    UClass* Found = FindObject<UClass>(ANY_PACKAGE, *T);
+    if (!Found && !T.StartsWith(TEXT("U")))
+    {
+        Found = FindObject<UClass>(ANY_PACKAGE, *(FString(TEXT("U")) + T));
+    }
+    if (!Found && !T.EndsWith(TEXT("Library")))
+    {
+        Found = FindObject<UClass>(ANY_PACKAGE, *(FString(TEXT("U")) + T + TEXT("Library")));
+    }
+    if (!Found && !T.EndsWith(TEXT("Component")))
+    {
+        Found = FindObject<UClass>(ANY_PACKAGE, *(FString(TEXT("U")) + T + TEXT("Component")));
+    }
+    return Found;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleSearchBlueprintFunctions(const TSharedPtr<FJsonObject>& Params)
+{
+    FString Query;
+    if (!Params->TryGetStringField(TEXT("query"), Query) && !Params->TryGetStringField(TEXT("name"), Query))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'query' parameter"));
+    }
+    Query = Query.TrimStartAndEnd();
+    if (Query.IsEmpty())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("'query' is empty"));
+    }
+
+    FString Target;
+    Params->TryGetStringField(TEXT("target"), Target);
+    Params->TryGetStringField(TEXT("class"), Target);
+
+    int32 Limit = 25;
+    if (Params->HasField(TEXT("limit")))
+    {
+        Limit = (int32)Params->GetNumberField(TEXT("limit"));
+        Limit = FMath::Clamp(Limit, 1, 200);
+    }
+
+    UClass* TargetClass = nullptr;
+    if (!Target.IsEmpty())
+    {
+        TargetClass = ResolveClassBestEffort(Target);
+    }
+
+    const FString QueryLower = Query.ToLower();
+    TArray<TSharedPtr<FJsonValue>> Matches;
+
+    auto MaybeAddFunction = [&](UFunction* Function, UClass* OwnerClass)
+    {
+        if ((int32)Matches.Num() >= Limit) return;
+        if (!IsBlueprintCallableFunction(Function)) return;
+
+        const FString Name = Function->GetName();
+        const FString Display = SafeDisplayName(Function);
+        if (!MatchesQuery(QueryLower, Name) && !MatchesQuery(QueryLower, Display)) return;
+
+        TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+        Obj->SetStringField(TEXT("functionName"), Name);
+        Obj->SetStringField(TEXT("displayName"), Display);
+        if (OwnerClass)
+        {
+            Obj->SetStringField(TEXT("ownerClass"), OwnerClass->GetName());
+            Obj->SetStringField(TEXT("ownerPath"), OwnerClass->GetPathName());
+        }
+        Obj->SetBoolField(TEXT("isStatic"), Function->HasAnyFunctionFlags(FUNC_Static));
+
+        // Minimal signature info.
+        TArray<TSharedPtr<FJsonValue>> Inputs;
+        TArray<TSharedPtr<FJsonValue>> Outputs;
+        for (TFieldIterator<FProperty> It(Function); It; ++It)
+        {
+            FProperty* Prop = *It;
+            if (!Prop) continue;
+            const bool bIsReturn = Prop->HasAnyPropertyFlags(CPF_ReturnParm);
+            const bool bIsOut = Prop->HasAnyPropertyFlags(CPF_OutParm) && !Prop->HasAnyPropertyFlags(CPF_ConstParm);
+
+            TSharedPtr<FJsonObject> P = MakeShared<FJsonObject>();
+            P->SetStringField(TEXT("name"), Prop->GetName());
+            P->SetStringField(TEXT("type"), Prop->GetCPPType());
+
+            if (bIsReturn || bIsOut)
+            {
+                Outputs.Add(MakeShared<FJsonValueObject>(P));
+            }
+            else
+            {
+                Inputs.Add(MakeShared<FJsonValueObject>(P));
+            }
+        }
+        Obj->SetArrayField(TEXT("inputs"), Inputs);
+        Obj->SetArrayField(TEXT("outputs"), Outputs);
+
+        Matches.Add(MakeShared<FJsonValueObject>(Obj));
+    };
+
+    if (TargetClass)
+    {
+        for (TFieldIterator<UFunction> FuncIt(TargetClass, EFieldIteratorFlags::IncludeSuper); FuncIt; ++FuncIt)
+        {
+            MaybeAddFunction(*FuncIt, TargetClass);
+            if ((int32)Matches.Num() >= Limit) break;
+        }
+    }
+    else
+    {
+        for (TObjectIterator<UClass> ClassIt; ClassIt; ++ClassIt)
+        {
+            UClass* Class = *ClassIt;
+            if (!Class) continue;
+            if (!Class->IsChildOf(UBlueprintFunctionLibrary::StaticClass())) continue;
+            if (Class->HasAnyClassFlags(CLASS_Deprecated)) continue;
+
+            for (TFieldIterator<UFunction> FuncIt(Class, EFieldIteratorFlags::ExcludeSuper); FuncIt; ++FuncIt)
+            {
+                MaybeAddFunction(*FuncIt, Class);
+                if ((int32)Matches.Num() >= Limit) break;
+            }
+            if ((int32)Matches.Num() >= Limit) break;
+        }
+    }
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetStringField(TEXT("query"), Query);
+    if (!Target.IsEmpty()) Result->SetStringField(TEXT("target"), Target);
+    Result->SetNumberField(TEXT("count"), Matches.Num());
+    Result->SetArrayField(TEXT("matches"), Matches);
+    return Result;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleResolveBlueprintFunction(const TSharedPtr<FJsonObject>& Params)
+{
+    FString FunctionName;
+    if (!Params->TryGetStringField(TEXT("function_name"), FunctionName) &&
+        !Params->TryGetStringField(TEXT("name"), FunctionName) &&
+        !Params->TryGetStringField(TEXT("query"), FunctionName))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'function_name' parameter"));
+    }
+    FunctionName = FunctionName.TrimStartAndEnd();
+    if (FunctionName.IsEmpty())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("'function_name' is empty"));
+    }
+
+    FString Target;
+    Params->TryGetStringField(TEXT("target"), Target);
+    Params->TryGetStringField(TEXT("class"), Target);
+
+    UClass* TargetClass = nullptr;
+    if (!Target.IsEmpty())
+    {
+        TargetClass = ResolveClassBestEffort(Target);
+    }
+
+    UFunction* Resolved = nullptr;
+    UClass* Owner = nullptr;
+
+    auto SearchClass = [&](UClass* Class)
+    {
+        if (!Class || Resolved) return;
+        for (TFieldIterator<UFunction> FuncIt(Class, EFieldIteratorFlags::IncludeSuper); FuncIt; ++FuncIt)
+        {
+            UFunction* F = *FuncIt;
+            if (!IsBlueprintCallableFunction(F)) continue;
+            if (F->GetName().Equals(FunctionName, ESearchCase::IgnoreCase))
+            {
+                Resolved = F;
+                Owner = Class;
+                return;
+            }
+        }
+    };
+
+    if (TargetClass)
+    {
+        SearchClass(TargetClass);
+    }
+    else
+    {
+        // Prefer common Blueprint libraries first.
+        const TArray<FString> Preferred = { TEXT("KismetMathLibrary"), TEXT("KismetSystemLibrary"), TEXT("GameplayStatics") };
+        for (const FString& Name : Preferred)
+        {
+            if (Resolved) break;
+            SearchClass(ResolveClassBestEffort(Name));
+        }
+
+        if (!Resolved)
+        {
+            for (TObjectIterator<UClass> ClassIt; ClassIt; ++ClassIt)
+            {
+                UClass* Class = *ClassIt;
+                if (!Class) continue;
+                if (!Class->IsChildOf(UBlueprintFunctionLibrary::StaticClass())) continue;
+                SearchClass(Class);
+                if (Resolved) break;
+            }
+        }
+    }
+
+    if (!Resolved || !Owner)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(
+            FString::Printf(TEXT("Function not found or not Blueprint-callable: %s"), *FunctionName));
+    }
+
+    TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+    Result->SetStringField(TEXT("functionName"), Resolved->GetName());
+    Result->SetStringField(TEXT("displayName"), SafeDisplayName(Resolved));
+    Result->SetStringField(TEXT("ownerClass"), Owner->GetName());
+    Result->SetStringField(TEXT("ownerPath"), Owner->GetPathName());
+
+    // Suggest params for add_blueprint_function_node (caller must add blueprint_name).
+    TSharedPtr<FJsonObject> Suggested = MakeShared<FJsonObject>();
+    Suggested->SetStringField(TEXT("function_name"), Resolved->GetName());
+    Suggested->SetStringField(TEXT("function_owner_path"), Owner->GetPathName());
+    Result->SetObjectField(TEXT("suggested"), Suggested);
+
+    return Result;
+}
+
 TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleAddBlueprintVariable(const TSharedPtr<FJsonObject>& Params)
 {
     // Get required parameters
@@ -690,6 +1039,28 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleAddBlueprintVaria
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'variable_type' parameter"));
     }
+    VariableType = VariableType.TrimStartAndEnd();
+    const FString VariableTypeLower = VariableType.ToLower();
+    if (VariableTypeLower == TEXT("bool") || VariableTypeLower == TEXT("boolean"))
+    {
+        VariableType = TEXT("Boolean");
+    }
+    else if (VariableTypeLower == TEXT("int") || VariableTypeLower == TEXT("integer"))
+    {
+        VariableType = TEXT("Integer");
+    }
+    else if (VariableTypeLower == TEXT("float") || VariableTypeLower == TEXT("number") || VariableTypeLower == TEXT("double"))
+    {
+        VariableType = TEXT("Float");
+    }
+    else if (VariableTypeLower == TEXT("string") || VariableTypeLower == TEXT("str"))
+    {
+        VariableType = TEXT("String");
+    }
+    else if (VariableTypeLower == TEXT("vector") || VariableTypeLower == TEXT("vec3"))
+    {
+        VariableType = TEXT("Vector");
+    }
 
     // Get optional parameters
     bool IsExposed = false;
@@ -921,4 +1292,4 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintNodeCommands::HandleFindBlueprintNode
     ResultObj->SetArrayField(TEXT("node_guids"), NodeGuidArray);
     
     return ResultObj;
-} 
+}