flockbay 0.10.15 → 0.10.16

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

@@ -16,6 +16,7 @@
 #include "Components/LightComponent.h"
 #include "Components/PrimitiveComponent.h"
 #include "Components/SceneComponent.h"
+#include "UObject/UnrealType.h"
 #include "UObject/UObjectIterator.h"
 #include "Engine/Selection.h"
 #include "EditorAssetLibrary.h"
@@ -95,6 +96,19 @@ FVector2D FUnrealMCPCommonUtils::GetVector2DFromJson(const TSharedPtr<FJsonObjec
         return Result;
     }
     
+    // Accept either [x,y] or {x,y}.
+    const TSharedPtr<FJsonObject>* ObjValue = nullptr;
+    if (JsonObject->TryGetObjectField(FieldName, ObjValue) && ObjValue && ObjValue->IsValid())
+    {
+        double X = 0.0;
+        double Y = 0.0;
+        (*ObjValue)->TryGetNumberField(TEXT("x"), X) || (*ObjValue)->TryGetNumberField(TEXT("X"), X);
+        (*ObjValue)->TryGetNumberField(TEXT("y"), Y) || (*ObjValue)->TryGetNumberField(TEXT("Y"), Y);
+        Result.X = (float)X;
+        Result.Y = (float)Y;
+        return Result;
+    }
+
     const TArray<TSharedPtr<FJsonValue>>* JsonArray;
     if (JsonObject->TryGetArrayField(FieldName, JsonArray) && JsonArray->Num() >= 2)
     {
@@ -114,6 +128,22 @@ FVector FUnrealMCPCommonUtils::GetVectorFromJson(const TSharedPtr<FJsonObject>&
         return Result;
     }
     
+    // Accept either [x,y,z] or {x,y,z}.
+    const TSharedPtr<FJsonObject>* ObjValue = nullptr;
+    if (JsonObject->TryGetObjectField(FieldName, ObjValue) && ObjValue && ObjValue->IsValid())
+    {
+        double X = 0.0;
+        double Y = 0.0;
+        double Z = 0.0;
+        ((*ObjValue)->TryGetNumberField(TEXT("x"), X) || (*ObjValue)->TryGetNumberField(TEXT("X"), X));
+        ((*ObjValue)->TryGetNumberField(TEXT("y"), Y) || (*ObjValue)->TryGetNumberField(TEXT("Y"), Y));
+        ((*ObjValue)->TryGetNumberField(TEXT("z"), Z) || (*ObjValue)->TryGetNumberField(TEXT("Z"), Z));
+        Result.X = (float)X;
+        Result.Y = (float)Y;
+        Result.Z = (float)Z;
+        return Result;
+    }
+
     const TArray<TSharedPtr<FJsonValue>>* JsonArray;
     if (JsonObject->TryGetArrayField(FieldName, JsonArray) && JsonArray->Num() >= 3)
     {
@@ -134,6 +164,22 @@ FRotator FUnrealMCPCommonUtils::GetRotatorFromJson(const TSharedPtr<FJsonObject>
         return Result;
     }
     
+    // Accept either [pitch,yaw,roll] or {pitch,yaw,roll}.
+    const TSharedPtr<FJsonObject>* ObjValue = nullptr;
+    if (JsonObject->TryGetObjectField(FieldName, ObjValue) && ObjValue && ObjValue->IsValid())
+    {
+        double Pitch = 0.0;
+        double Yaw = 0.0;
+        double Roll = 0.0;
+        ((*ObjValue)->TryGetNumberField(TEXT("pitch"), Pitch) || (*ObjValue)->TryGetNumberField(TEXT("Pitch"), Pitch));
+        ((*ObjValue)->TryGetNumberField(TEXT("yaw"), Yaw) || (*ObjValue)->TryGetNumberField(TEXT("Yaw"), Yaw));
+        ((*ObjValue)->TryGetNumberField(TEXT("roll"), Roll) || (*ObjValue)->TryGetNumberField(TEXT("Roll"), Roll));
+        Result.Pitch = (float)Pitch;
+        Result.Yaw = (float)Yaw;
+        Result.Roll = (float)Roll;
+        return Result;
+    }
+
     const TArray<TSharedPtr<FJsonValue>>* JsonArray;
     if (JsonObject->TryGetArrayField(FieldName, JsonArray) && JsonArray->Num() >= 3)
     {
@@ -153,8 +199,34 @@ UBlueprint* FUnrealMCPCommonUtils::FindBlueprint(const FString& BlueprintName)
 
 UBlueprint* FUnrealMCPCommonUtils::FindBlueprintByName(const FString& BlueprintName)
 {
-    FString AssetPath = TEXT("/Game/Blueprints/") + BlueprintName;
-    return LoadObject<UBlueprint>(nullptr, *AssetPath);
+    FString Trimmed = BlueprintName.TrimStartAndEnd();
+    if (Trimmed.IsEmpty())
+    {
+        return nullptr;
+    }
+
+    // Allow callers to pass either a simple asset name (BP_MyAsset),
+    // or a full object path (/Game/Path/BP_MyAsset.BP_MyAsset),
+    // or a Blueprint'...' soft path.
+    if (Trimmed.StartsWith(TEXT("/")) || Trimmed.StartsWith(TEXT("Blueprint'")))
+    {
+        UObject* Obj = LoadObject<UObject>(nullptr, *Trimmed);
+        if (!Obj && Trimmed.StartsWith(TEXT("/")) && !Trimmed.Contains(TEXT("'")))
+        {
+            Obj = LoadObject<UObject>(nullptr, *FString::Printf(TEXT("Blueprint'%s'"), *Trimmed));
+        }
+        if (UBlueprint* BP = Cast<UBlueprint>(Obj)) return BP;
+        if (UBlueprintGeneratedClass* BPGC = Cast<UBlueprintGeneratedClass>(Obj))
+        {
+            return Cast<UBlueprint>(BPGC->ClassGeneratedBy);
+        }
+        return nullptr;
+    }
+
+    FString AssetPath = TEXT("/Game/Blueprints/") + Trimmed;
+    if (UBlueprint* BP = LoadObject<UBlueprint>(nullptr, *AssetPath)) return BP;
+    if (UBlueprint* BP = LoadObject<UBlueprint>(nullptr, *FString::Printf(TEXT("Blueprint'%s'"), *AssetPath))) return BP;
+    return nullptr;
 }
 
 UEdGraph* FUnrealMCPCommonUtils::FindOrCreateEventGraph(UBlueprint* Blueprint)
@@ -463,6 +535,10 @@ TSharedPtr<FJsonObject> FUnrealMCPCommonUtils::ActorToJsonObject(AActor* Actor,
     TSharedPtr<FJsonObject> ActorObject = MakeShared<FJsonObject>();
     ActorObject->SetStringField(TEXT("name"), Actor->GetName());
     ActorObject->SetStringField(TEXT("class"), Actor->GetClass()->GetName());
+
+#if WITH_EDITOR
+    ActorObject->SetStringField(TEXT("label"), Actor->GetActorLabel());
+#endif
     
     FVector Location = Actor->GetActorLocation();
     TArray<TSharedPtr<FJsonValue>> LocationArray;
@@ -484,7 +560,100 @@ TSharedPtr<FJsonObject> FUnrealMCPCommonUtils::ActorToJsonObject(AActor* Actor,
     ScaleArray.Add(MakeShared<FJsonValueNumber>(Scale.Y));
     ScaleArray.Add(MakeShared<FJsonValueNumber>(Scale.Z));
     ActorObject->SetArrayField(TEXT("scale"), ScaleArray);
-    
+
+    if (!bDetailed)
+    {
+        return ActorObject;
+    }
+
+    const auto isEditableProperty = [](const FProperty* Prop) -> bool {
+        if (!Prop) return false;
+        if (!Prop->HasAnyPropertyFlags(CPF_Edit)) return false;
+        if (Prop->HasAnyPropertyFlags(CPF_Transient | CPF_Deprecated | CPF_DisableEditOnInstance)) return false;
+        return true;
+    };
+
+    const auto addPropertyDescriptors = [&](UObject* Obj, int32 Limit, TArray<TSharedPtr<FJsonValue>>& OutProps) {
+        if (!Obj) return;
+        int32 Count = 0;
+        for (TFieldIterator<FProperty> It(Obj->GetClass()); It; ++It)
+        {
+            FProperty* Prop = *It;
+            if (!isEditableProperty(Prop)) continue;
+            if (Limit > 0 && Count >= Limit) break;
+
+            TSharedPtr<FJsonObject> P = MakeShared<FJsonObject>();
+            P->SetStringField(TEXT("name"), Prop->GetName());
+            P->SetStringField(TEXT("type"), Prop->GetCPPType());
+            P->SetBoolField(TEXT("isArray"), Prop->IsA<FArrayProperty>());
+            OutProps.Add(MakeShared<FJsonValueObject>(P));
+            Count++;
+        }
+    };
+
+    // Actor editable properties
+    {
+        TArray<TSharedPtr<FJsonValue>> Props;
+        addPropertyDescriptors(Actor, 250, Props);
+        ActorObject->SetArrayField(TEXT("properties"), Props);
+    }
+
+    // Actor component pointer fields (useful for nested property paths like PointLightComponent.LightColor)
+    {
+        TArray<TSharedPtr<FJsonValue>> Fields;
+        int32 Count = 0;
+        for (TFieldIterator<FProperty> It(Actor->GetClass()); It; ++It)
+        {
+            FProperty* Prop = *It;
+            FObjectPropertyBase* ObjProp = CastField<FObjectPropertyBase>(Prop);
+            if (!ObjProp) continue;
+            if (!ObjProp->PropertyClass || !ObjProp->PropertyClass->IsChildOf(UActorComponent::StaticClass())) continue;
+            if (Count >= 50) break;
+
+            UObject* Ref = ObjProp->GetObjectPropertyValue_InContainer(Actor);
+            UActorComponent* Comp = Cast<UActorComponent>(Ref);
+
+            TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+            Obj->SetStringField(TEXT("property"), Prop->GetName());
+            Obj->SetStringField(TEXT("class"), ObjProp->PropertyClass->GetName());
+            if (Comp)
+            {
+                Obj->SetStringField(TEXT("componentName"), Comp->GetName());
+            }
+            Fields.Add(MakeShared<FJsonValueObject>(Obj));
+            Count++;
+        }
+        ActorObject->SetArrayField(TEXT("componentFields"), Fields);
+    }
+
+    // Components + their editable properties (best-effort, bounded)
+    {
+        TArray<TSharedPtr<FJsonValue>> Components;
+        TArray<UActorComponent*> Comps;
+        Actor->GetComponents(Comps);
+        Comps.Sort([](const UActorComponent& A, const UActorComponent& B) {
+            return A.GetFName().LexicalLess(B.GetFName());
+        });
+
+        int32 Added = 0;
+        for (UActorComponent* C : Comps)
+        {
+            if (!C) continue;
+            if (Added >= 50) break;
+            TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+            Obj->SetStringField(TEXT("name"), C->GetName());
+            Obj->SetStringField(TEXT("class"), C->GetClass()->GetName());
+
+            TArray<TSharedPtr<FJsonValue>> Props;
+            addPropertyDescriptors(C, 200, Props);
+            Obj->SetArrayField(TEXT("properties"), Props);
+
+            Components.Add(MakeShared<FJsonValueObject>(Obj));
+            Added++;
+        }
+        ActorObject->SetArrayField(TEXT("components"), Components);
+    }
+
     return ActorObject;
 }
 
@@ -518,14 +687,88 @@ bool FUnrealMCPCommonUtils::SetObjectProperty(UObject* Object, const FString& Pr
         return false;
     }
 
-    FProperty* Property = Object->GetClass()->FindPropertyByName(*PropertyName);
-    if (!Property)
+    const auto splitPath = [](const FString& Raw) -> TArray<FString> {
+        FString P = Raw;
+        P.ReplaceInline(TEXT("/"), TEXT("."), ESearchCase::IgnoreCase);
+        P = P.TrimStartAndEnd();
+        TArray<FString> Segs;
+        P.ParseIntoArray(Segs, TEXT("."), true);
+        Segs.RemoveAll([](const FString& S) { return S.TrimStartAndEnd().IsEmpty(); });
+        for (FString& S : Segs) S = S.TrimStartAndEnd();
+        return Segs;
+    };
+
+    const auto resolvePropertyPath = [&](UObject* Root, const FString& RawPath, UObject*& OutContainerObj, FProperty*& OutProp, void*& OutPropAddr) -> bool {
+        OutContainerObj = Root;
+        OutProp = nullptr;
+        OutPropAddr = nullptr;
+
+        const TArray<FString> Segs = splitPath(RawPath);
+        if (Segs.Num() == 0)
+        {
+            OutErrorMessage = TEXT("Property path is empty");
+            return false;
+        }
+
+        UObject* Current = Root;
+        for (int32 i = 0; i < Segs.Num(); i++)
+        {
+            const FString& Seg = Segs[i];
+            const bool bIsLeaf = (i == Segs.Num() - 1);
+
+            FProperty* Prop = Current->GetClass()->FindPropertyByName(*Seg);
+            if (!Prop)
+            {
+                OutErrorMessage = FString::Printf(TEXT("Property not found: %s"), *Seg);
+                return false;
+            }
+
+            if (bIsLeaf)
+            {
+                OutContainerObj = Current;
+                OutProp = Prop;
+                OutPropAddr = Prop->ContainerPtrToValuePtr<void>(Current);
+                return true;
+            }
+
+            FObjectPropertyBase* ObjProp = CastField<FObjectPropertyBase>(Prop);
+            if (!ObjProp)
+            {
+                OutErrorMessage = FString::Printf(TEXT("Unsupported property path segment (not an object): %s"), *Seg);
+                return false;
+            }
+
+            UObject* Next = ObjProp->GetObjectPropertyValue_InContainer(Current);
+            if (!Next)
+            {
+                OutErrorMessage = FString::Printf(TEXT("Null object at path segment: %s"), *Seg);
+                return false;
+            }
+            Current = Next;
+        }
+
+        OutErrorMessage = TEXT("Failed to resolve property path");
+        return false;
+    };
+
+    UObject* ContainerObj = nullptr;
+    FProperty* Property = nullptr;
+    void* PropertyAddr = nullptr;
+    if (!resolvePropertyPath(Object, PropertyName, ContainerObj, Property, PropertyAddr))
+    {
+        return false;
+    }
+
+    if (!Property || !ContainerObj || !PropertyAddr)
     {
-        OutErrorMessage = FString::Printf(TEXT("Property not found: %s"), *PropertyName);
+        OutErrorMessage = TEXT("Property resolution failed");
         return false;
     }
 
-    void* PropertyAddr = Property->ContainerPtrToValuePtr<void>(Object);
+    // Mark dirty for undo/redo and details panel refresh (editor only).
+#if WITH_EDITOR
+    ContainerObj->Modify();
+#endif
     
     // Handle different property types
     if (Property->IsA<FBoolProperty>())
@@ -553,6 +796,231 @@ bool FUnrealMCPCommonUtils::SetObjectProperty(UObject* Object, const FString& Pr
         ((FStrProperty*)Property)->SetPropertyValue(PropertyAddr, Value->AsString());
         return true;
     }
+    else if (Property->IsA<FNameProperty>())
+    {
+        const FString S = Value->Type == EJson::String ? Value->AsString() : FString::Printf(TEXT("%g"), Value->AsNumber());
+        CastFieldChecked<FNameProperty>(Property)->SetPropertyValue(PropertyAddr, FName(*S));
+        return true;
+    }
+    else if (Property->IsA<FTextProperty>())
+    {
+        const FString S = Value->Type == EJson::String ? Value->AsString() : FString::Printf(TEXT("%g"), Value->AsNumber());
+        CastFieldChecked<FTextProperty>(Property)->SetPropertyValue(PropertyAddr, FText::FromString(S));
+        return true;
+    }
+    else if (Property->IsA<FStructProperty>())
+    {
+        FStructProperty* StructProp = CastField<FStructProperty>(Property);
+        if (!StructProp || !StructProp->Struct)
+        {
+            OutErrorMessage = FString::Printf(TEXT("Invalid struct property: %s"), *PropertyName);
+            return false;
+        }
+
+        const UScriptStruct* S = StructProp->Struct;
+        if (S == TBaseStructure<FVector>::Get())
+        {
+            if (Value->Type != EJson::Array || Value->AsArray().Num() != 3)
+            {
+                OutErrorMessage = TEXT("FVector requires an array of 3 numbers");
+                return false;
+            }
+            const auto& Arr = Value->AsArray();
+            const FVector V((float)Arr[0]->AsNumber(), (float)Arr[1]->AsNumber(), (float)Arr[2]->AsNumber());
+            StructProp->CopySingleValue(PropertyAddr, &V);
+            return true;
+        }
+        if (S == TBaseStructure<FVector2D>::Get())
+        {
+            if (Value->Type != EJson::Array || Value->AsArray().Num() != 2)
+            {
+                OutErrorMessage = TEXT("FVector2D requires an array of 2 numbers");
+                return false;
+            }
+            const auto& Arr = Value->AsArray();
+            const FVector2D V((float)Arr[0]->AsNumber(), (float)Arr[1]->AsNumber());
+            StructProp->CopySingleValue(PropertyAddr, &V);
+            return true;
+        }
+        if (S == TBaseStructure<FRotator>::Get())
+        {
+            if (Value->Type != EJson::Array || Value->AsArray().Num() != 3)
+            {
+                OutErrorMessage = TEXT("FRotator requires an array of 3 numbers [Pitch,Yaw,Roll]");
+                return false;
+            }
+            const auto& Arr = Value->AsArray();
+            const FRotator R((float)Arr[0]->AsNumber(), (float)Arr[1]->AsNumber(), (float)Arr[2]->AsNumber());
+            StructProp->CopySingleValue(PropertyAddr, &R);
+            return true;
+        }
+        if (S == TBaseStructure<FLinearColor>::Get())
+        {
+            if (Value->Type != EJson::Array || (Value->AsArray().Num() != 3 && Value->AsArray().Num() != 4))
+            {
+                OutErrorMessage = TEXT("FLinearColor requires an array of 3 or 4 numbers [R,G,B,(A)]");
+                return false;
+            }
+            const auto& Arr = Value->AsArray();
+            const float A = Arr.Num() >= 4 ? (float)Arr[3]->AsNumber() : 1.0f;
+            const FLinearColor C((float)Arr[0]->AsNumber(), (float)Arr[1]->AsNumber(), (float)Arr[2]->AsNumber(), A);
+            StructProp->CopySingleValue(PropertyAddr, &C);
+            return true;
+        }
+        if (S == TBaseStructure<FColor>::Get())
+        {
+            if (Value->Type != EJson::Array || (Value->AsArray().Num() != 3 && Value->AsArray().Num() != 4))
+            {
+                OutErrorMessage = TEXT("FColor requires an array of 3 or 4 numbers [R,G,B,(A)]");
+                return false;
+            }
+            const auto& Arr = Value->AsArray();
+            const double r = Arr[0]->AsNumber();
+            const double g = Arr[1]->AsNumber();
+            const double b = Arr[2]->AsNumber();
+            const double a = Arr.Num() >= 4 ? Arr[3]->AsNumber() : 255.0;
+            const bool bLooksNormalized = r <= 1.0 && g <= 1.0 && b <= 1.0 && a <= 1.0;
+            const auto toByte = [&](double v) -> uint8 {
+                const double x = bLooksNormalized ? v * 255.0 : v;
+                return (uint8)FMath::Clamp((int32)FMath::RoundHalfToZero(x), 0, 255);
+            };
+            const FColor C(toByte(r), toByte(g), toByte(b), toByte(a));
+            StructProp->CopySingleValue(PropertyAddr, &C);
+            return true;
+        }
+
+        OutErrorMessage = FString::Printf(TEXT("Unsupported struct type: %s"), *S->GetName());
+        return false;
+    }
+    else if (Property->IsA<FObjectPropertyBase>())
+    {
+        FObjectPropertyBase* ObjProp = CastField<FObjectPropertyBase>(Property);
+        if (!ObjProp)
+        {
+            OutErrorMessage = FString::Printf(TEXT("Invalid ObjectProperty: %s"), *PropertyName);
+            return false;
+        }
+
+        if (Value->Type == EJson::Null)
+        {
+            ObjProp->SetObjectPropertyValue(PropertyAddr, nullptr);
+            return true;
+        }
+
+        if (Value->Type != EJson::String)
+        {
+            OutErrorMessage = FString::Printf(TEXT("ObjectProperty requires a string object path (or null): %s"), *PropertyName);
+            return false;
+        }
+
+        FString Path = Value->AsString().TrimStartAndEnd();
+        if (Path.IsEmpty())
+        {
+            ObjProp->SetObjectPropertyValue(PropertyAddr, nullptr);
+            return true;
+        }
+
+        UObject* Loaded = StaticLoadObject(ObjProp->PropertyClass, nullptr, *Path);
+        if (!Loaded && !Path.Contains(TEXT("'")))
+        {
+            Loaded = StaticLoadObject(
+                ObjProp->PropertyClass,
+                nullptr,
+                *FString::Printf(TEXT("%s'%s'"), *ObjProp->PropertyClass->GetName(), *Path));
+        }
+
+        if (!Loaded)
+        {
+            OutErrorMessage = FString::Printf(TEXT("Failed to load object for %s: %s"), *PropertyName, *Path);
+            return false;
+        }
+
+        ObjProp->SetObjectPropertyValue(PropertyAddr, Loaded);
+        return true;
+    }
+    else if (Property->IsA<FArrayProperty>())
+    {
+        if (Value->Type != EJson::Array)
+        {
+            OutErrorMessage = FString::Printf(TEXT("ArrayProperty requires an array value: %s"), *PropertyName);
+            return false;
+        }
+
+        FArrayProperty* ArrProp = CastField<FArrayProperty>(Property);
+        if (!ArrProp || !ArrProp->Inner)
+        {
+            OutErrorMessage = FString::Printf(TEXT("Invalid ArrayProperty: %s"), *PropertyName);
+            return false;
+        }
+
+        const TArray<TSharedPtr<FJsonValue>>& Arr = Value->AsArray();
+        FScriptArrayHelper Helper(ArrProp, PropertyAddr);
+        Helper.Resize(Arr.Num());
+
+        for (int32 i = 0; i < Arr.Num(); i++)
+        {
+            void* ElemPtr = Helper.GetRawPtr(i);
+            const TSharedPtr<FJsonValue>& Elem = Arr[i];
+
+            if (FObjectPropertyBase* InnerObj = CastField<FObjectPropertyBase>(ArrProp->Inner))
+            {
+                if (!Elem.IsValid() || Elem->Type == EJson::Null)
+                {
+                    InnerObj->SetObjectPropertyValue(ElemPtr, nullptr);
+                    continue;
+                }
+                if (Elem->Type != EJson::String)
+                {
+                    OutErrorMessage = FString::Printf(TEXT("Array element %d must be a string object path (or null) for %s"), i, *PropertyName);
+                    return false;
+                }
+                FString Path = Elem->AsString().TrimStartAndEnd();
+                UObject* Loaded = Path.IsEmpty() ? nullptr : StaticLoadObject(InnerObj->PropertyClass, nullptr, *Path);
+                if (!Loaded && !Path.IsEmpty() && !Path.Contains(TEXT("'")))
+                {
+                    Loaded = StaticLoadObject(
+                        InnerObj->PropertyClass,
+                        nullptr,
+                        *FString::Printf(TEXT("%s'%s'"), *InnerObj->PropertyClass->GetName(), *Path));
+                }
+                if (!Path.IsEmpty() && !Loaded)
+                {
+                    OutErrorMessage = FString::Printf(TEXT("Failed to load object for %s[%d]: %s"), *PropertyName, i, *Path);
+                    return false;
+                }
+                InnerObj->SetObjectPropertyValue(ElemPtr, Loaded);
+                continue;
+            }
+
+            if (FStrProperty* InnerStr = CastField<FStrProperty>(ArrProp->Inner))
+            {
+                if (!Elem.IsValid() || Elem->Type == EJson::Null)
+                {
+                    InnerStr->SetPropertyValue(ElemPtr, TEXT(""));
+                    continue;
+                }
+                InnerStr->SetPropertyValue(ElemPtr, Elem->Type == EJson::String ? Elem->AsString() : FString::Printf(TEXT("%g"), Elem->AsNumber()));
+                continue;
+            }
+
+            if (FNumericProperty* InnerNum = CastField<FNumericProperty>(ArrProp->Inner))
+            {
+                if (!Elem.IsValid() || Elem->Type != EJson::Number)
+                {
+                    OutErrorMessage = FString::Printf(TEXT("Array element %d must be a number for %s"), i, *PropertyName);
+                    return false;
+                }
+                if (InnerNum->IsInteger()) InnerNum->SetIntPropertyValue(ElemPtr, (int64)Elem->AsNumber());
+                else InnerNum->SetFloatingPointPropertyValue(ElemPtr, Elem->AsNumber());
+                continue;
+            }
+
+            OutErrorMessage = FString::Printf(TEXT("Unsupported ArrayProperty element type: %s for %s"), *ArrProp->Inner->GetClass()->GetName(), *PropertyName);
+            return false;
+        }
+
+        return true;
+    }
     else if (Property->IsA<FByteProperty>())
     {
         FByteProperty* ByteProp = CastField<FByteProperty>(Property);
@@ -706,4 +1174,4 @@ bool FUnrealMCPCommonUtils::SetObjectProperty(UObject* Object, const FString& Pr
     OutErrorMessage = FString::Printf(TEXT("Unsupported property type: %s for property %s"), 
                                     *Property->GetClass()->GetName(), *PropertyName);
     return false;
-} 
+}