flockbay 0.10.15

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

@@ -0,0 +1,896 @@
+#include "Commands/UnrealMCPEditorCommands.h"
+#include "Commands/UnrealMCPCommonUtils.h"
+#include "Editor.h"
+#include "EditorViewportClient.h"
+#include "LevelEditorViewport.h"
+#include "IAssetViewport.h"
+#include "ImageUtils.h"
+#include "HighResScreenshot.h"
+#include "Engine/GameViewportClient.h"
+#include "Misc/FileHelper.h"
+#include "Misc/Paths.h"
+#include "HAL/FileManager.h"
+#include "GameFramework/Actor.h"
+#include "Engine/Selection.h"
+#include "Kismet/GameplayStatics.h"
+#include "Engine/StaticMeshActor.h"
+#include "Engine/StaticMesh.h"
+#include "Engine/DirectionalLight.h"
+#include "Engine/PointLight.h"
+#include "Engine/SpotLight.h"
+#include "Camera/CameraActor.h"
+#include "Components/StaticMeshComponent.h"
+#include "EditorSubsystem.h"
+#include "Subsystems/EditorActorSubsystem.h"
+#include "Engine/Blueprint.h"
+#include "Engine/BlueprintGeneratedClass.h"
+#include "UnrealEdGlobals.h"
+#include "Editor/UnrealEdEngine.h"
+#include "UObject/UnrealType.h"
+#include "Modules/ModuleManager.h"
+#include "LevelEditor.h"
+#include "PlayInEditorDataTypes.h"
+#include "Settings/LevelEditorPlaySettings.h"
+#include "Framework/Application/SlateApplication.h"
+
+FUnrealMCPEditorCommands::FUnrealMCPEditorCommands()
+{
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleCommand(const FString& CommandType, const TSharedPtr<FJsonObject>& Params)
+{
+    // Actor manipulation commands
+    if (CommandType == TEXT("get_actors_in_level"))
+    {
+        return HandleGetActorsInLevel(Params);
+    }
+    else if (CommandType == TEXT("find_actors_by_name"))
+    {
+        return HandleFindActorsByName(Params);
+    }
+    else if (CommandType == TEXT("spawn_actor") || CommandType == TEXT("create_actor"))
+    {
+        if (CommandType == TEXT("create_actor"))
+        {
+            UE_LOG(LogTemp, Warning, TEXT("'create_actor' command is deprecated and will be removed in a future version. Please use 'spawn_actor' instead."));
+        }
+        return HandleSpawnActor(Params);
+    }
+    else if (CommandType == TEXT("delete_actor"))
+    {
+        return HandleDeleteActor(Params);
+    }
+    else if (CommandType == TEXT("set_actor_transform"))
+    {
+        return HandleSetActorTransform(Params);
+    }
+    else if (CommandType == TEXT("get_actor_properties"))
+    {
+        return HandleGetActorProperties(Params);
+    }
+    else if (CommandType == TEXT("set_actor_property"))
+    {
+        return HandleSetActorProperty(Params);
+    }
+    // Blueprint actor spawning
+    else if (CommandType == TEXT("spawn_blueprint_actor"))
+    {
+        return HandleSpawnBlueprintActor(Params);
+    }
+    // Editor viewport commands
+    else if (CommandType == TEXT("focus_viewport"))
+    {
+        return HandleFocusViewport(Params);
+    }
+    else if (CommandType == TEXT("take_screenshot"))
+    {
+        return HandleTakeScreenshot(Params);
+    }
+    else if (CommandType == TEXT("get_play_in_editor_status"))
+    {
+        return HandleGetPlayInEditorStatus(Params);
+    }
+    else if (CommandType == TEXT("play_in_editor"))
+    {
+        return HandlePlayInEditor(Params);
+    }
+    else if (CommandType == TEXT("play_in_editor_windowed"))
+    {
+        return HandlePlayInEditorWindowed(Params);
+    }
+    else if (CommandType == TEXT("stop_play_in_editor"))
+    {
+        return HandleStopPlayInEditor(Params);
+    }
+    
+    return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Unknown editor command: %s"), *CommandType));
+}
+
+static TSharedPtr<FJsonObject> CreatePlayStatusResponse()
+{
+    if (!GEditor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
+    }
+
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetBoolField(TEXT("isPlaySessionInProgress"), GEditor->IsPlaySessionInProgress());
+    ResultObj->SetBoolField(TEXT("isPlaySessionRequestQueued"), GEditor->IsPlaySessionRequestQueued());
+    ResultObj->SetBoolField(TEXT("isPlayingSessionInEditor"), GEditor->IsPlayingSessionInEditor());
+    return ResultObj;
+}
+
+static bool IsSafeToModifyEditorWorld(FString& OutError)
+{
+    if (!GEditor)
+    {
+        OutError = TEXT("Editor is not available (GEditor is null).");
+        return false;
+    }
+
+    if (GEditor->IsPlaySessionInProgress())
+    {
+        OutError = TEXT("Play-In-Editor is running or queued. Stop PIE before modifying the editor world (use stop_play_in_editor).");
+        return false;
+    }
+
+    return true;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleGetPlayInEditorStatus(const TSharedPtr<FJsonObject>& Params)
+{
+    return CreatePlayStatusResponse();
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandlePlayInEditor(const TSharedPtr<FJsonObject>& Params)
+{
+    if (!GEditor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
+    }
+
+    if (GEditor->IsPlaySessionInProgress())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Play session already running or queued."));
+    }
+
+    // Use the active editor viewport, matching how the LevelEditor subsystem triggers PIE.
+    FLevelEditorModule* LevelEditorModule = FModuleManager::LoadModulePtr<FLevelEditorModule>(TEXT("LevelEditor"));
+    if (!LevelEditorModule)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("LevelEditor module not available."));
+    }
+
+    TSharedPtr<IAssetViewport> ActiveViewport = LevelEditorModule->GetFirstActiveViewport();
+    if (!ActiveViewport.IsValid())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("No active level viewport. Click the viewport and retry."));
+    }
+
+    FRequestPlaySessionParams SessionParams;
+    SessionParams.WorldType = EPlaySessionWorldType::PlayInEditor;
+    SessionParams.DestinationSlateViewport = ActiveViewport;
+
+    GEditor->RequestPlaySession(SessionParams);
+    const bool bQueued = GEditor->IsPlaySessionRequestQueued();
+
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetBoolField(TEXT("requested"), true);
+    ResultObj->SetBoolField(TEXT("queued"), bQueued);
+    ResultObj->SetBoolField(TEXT("started"), bQueued);
+    ResultObj->SetStringField(TEXT("mode"), TEXT("pie"));
+    return ResultObj;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandlePlayInEditorWindowed(const TSharedPtr<FJsonObject>& Params)
+{
+    if (!GEditor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
+    }
+
+    if (GEditor->IsPlaySessionInProgress())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Play session already running or queued."));
+    }
+
+    // Match the editor's built-in "New Editor Window (PIE)" behavior by setting the play mode type and
+    // not specifying a DestinationSlateViewport.
+    ULevelEditorPlaySettings* PlaySettings = GetMutableDefault<ULevelEditorPlaySettings>();
+    if (PlaySettings)
+    {
+        PlaySettings->LastExecutedPlayModeType = EPlayModeType::PlayMode_InEditorFloating;
+
+        if (FProperty* Prop = ULevelEditorPlaySettings::StaticClass()->FindPropertyByName(
+                GET_MEMBER_NAME_CHECKED(ULevelEditorPlaySettings, LastExecutedPlayModeType)))
+        {
+            FPropertyChangedEvent PropChangeEvent(Prop);
+            PlaySettings->PostEditChangeProperty(PropChangeEvent);
+        }
+
+        PlaySettings->SaveConfig();
+    }
+
+    const bool bAtPlayerStart =
+        PlaySettings && PlaySettings->LastExecutedPlayModeLocation == EPlayModeLocations::PlayLocation_DefaultPlayerStart;
+
+    FRequestPlaySessionParams SessionParams;
+    SessionParams.WorldType = EPlaySessionWorldType::PlayInEditor;
+
+    // If the user is playing from current camera location, use the active viewport camera as the start transform.
+    if (!bAtPlayerStart)
+    {
+        FLevelEditorModule* LevelEditorModule = FModuleManager::LoadModulePtr<FLevelEditorModule>(TEXT("LevelEditor"));
+        if (LevelEditorModule)
+        {
+            TSharedPtr<IAssetViewport> ActiveViewport = LevelEditorModule->GetFirstActiveViewport();
+            if (ActiveViewport.IsValid() && FSlateApplication::IsInitialized() &&
+                FSlateApplication::Get().FindWidgetWindow(ActiveViewport->AsWidget()).IsValid())
+            {
+                SessionParams.StartLocation = ActiveViewport->GetAssetViewportClient().GetViewLocation();
+                SessionParams.StartRotation = ActiveViewport->GetAssetViewportClient().GetViewRotation();
+            }
+        }
+    }
+
+    GEditor->RequestPlaySession(SessionParams);
+    const bool bQueued = GEditor->IsPlaySessionRequestQueued();
+
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetBoolField(TEXT("requested"), true);
+    ResultObj->SetBoolField(TEXT("queued"), bQueued);
+    ResultObj->SetBoolField(TEXT("started"), bQueued);
+    ResultObj->SetStringField(TEXT("mode"), TEXT("pie_new_window"));
+    return ResultObj;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleStopPlayInEditor(const TSharedPtr<FJsonObject>& Params)
+{
+    if (!GEditor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Editor is not available (GEditor is null)."));
+    }
+
+    if (GEditor->IsPlaySessionRequestQueued() && !GEditor->IsPlayingSessionInEditor())
+    {
+        GEditor->CancelRequestPlaySession();
+        TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+        ResultObj->SetBoolField(TEXT("stopped"), true);
+        ResultObj->SetBoolField(TEXT("canceled"), true);
+        return ResultObj;
+    }
+
+    if (!GEditor->IsPlayingSessionInEditor())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("No play session is running."));
+    }
+
+    GEditor->RequestEndPlayMap();
+
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetBoolField(TEXT("stopped"), true);
+    return ResultObj;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleGetActorsInLevel(const TSharedPtr<FJsonObject>& Params)
+{
+    TArray<AActor*> AllActors;
+    UGameplayStatics::GetAllActorsOfClass(GWorld, AActor::StaticClass(), AllActors);
+    
+    TArray<TSharedPtr<FJsonValue>> ActorArray;
+    for (AActor* Actor : AllActors)
+    {
+        if (Actor)
+        {
+            ActorArray.Add(FUnrealMCPCommonUtils::ActorToJson(Actor));
+        }
+    }
+    
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetArrayField(TEXT("actors"), ActorArray);
+    
+    return ResultObj;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleFindActorsByName(const TSharedPtr<FJsonObject>& Params)
+{
+    FString Pattern;
+    if (!Params->TryGetStringField(TEXT("pattern"), Pattern))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'pattern' parameter"));
+    }
+    
+    TArray<AActor*> AllActors;
+    UGameplayStatics::GetAllActorsOfClass(GWorld, AActor::StaticClass(), AllActors);
+    
+    TArray<TSharedPtr<FJsonValue>> MatchingActors;
+    for (AActor* Actor : AllActors)
+    {
+        if (Actor && Actor->GetName().Contains(Pattern))
+        {
+            MatchingActors.Add(FUnrealMCPCommonUtils::ActorToJson(Actor));
+        }
+    }
+    
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetArrayField(TEXT("actors"), MatchingActors);
+    
+    return ResultObj;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSpawnActor(const TSharedPtr<FJsonObject>& Params)
+{
+    {
+        FString Err;
+        if (!IsSafeToModifyEditorWorld(Err))
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(Err);
+        }
+    }
+
+    // Get required parameters
+    FString ActorType;
+    if (!Params->TryGetStringField(TEXT("type"), ActorType))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'type' parameter"));
+    }
+
+    // Get actor name (required parameter)
+    FString ActorName;
+    if (!Params->TryGetStringField(TEXT("name"), ActorName))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'name' parameter"));
+    }
+
+    // Get optional transform parameters
+    FVector Location(0.0f, 0.0f, 0.0f);
+    FRotator Rotation(0.0f, 0.0f, 0.0f);
+    FVector Scale(1.0f, 1.0f, 1.0f);
+
+    if (Params->HasField(TEXT("location")))
+    {
+        Location = FUnrealMCPCommonUtils::GetVectorFromJson(Params, TEXT("location"));
+    }
+    if (Params->HasField(TEXT("rotation")))
+    {
+        Rotation = FUnrealMCPCommonUtils::GetRotatorFromJson(Params, TEXT("rotation"));
+    }
+    if (Params->HasField(TEXT("scale")))
+    {
+        Scale = FUnrealMCPCommonUtils::GetVectorFromJson(Params, TEXT("scale"));
+    }
+
+    // Create the actor based on type
+    AActor* NewActor = nullptr;
+    UWorld* World = GEditor->GetEditorWorldContext().World();
+
+    if (!World)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to get editor world"));
+    }
+
+    // Check if an actor with this name already exists
+    TArray<AActor*> AllActors;
+    UGameplayStatics::GetAllActorsOfClass(World, AActor::StaticClass(), AllActors);
+    for (AActor* Actor : AllActors)
+    {
+        if (Actor && Actor->GetName() == ActorName)
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Actor with name '%s' already exists"), *ActorName));
+        }
+    }
+
+    FActorSpawnParameters SpawnParams;
+    SpawnParams.Name = *ActorName;
+
+    if (ActorType == TEXT("StaticMeshActor"))
+    {
+        NewActor = World->SpawnActor<AStaticMeshActor>(AStaticMeshActor::StaticClass(), Location, Rotation, SpawnParams);
+
+        // Optional: assign a StaticMesh at spawn time (preferred, since nested component property setting is limited).
+        FString StaticMeshPath;
+        if (Params->TryGetStringField(TEXT("static_mesh_path"), StaticMeshPath) ||
+            Params->TryGetStringField(TEXT("static_mesh"), StaticMeshPath))
+        {
+            StaticMeshPath = StaticMeshPath.TrimStartAndEnd();
+            if (!StaticMeshPath.IsEmpty())
+            {
+                UStaticMesh* StaticMesh = LoadObject<UStaticMesh>(nullptr, *StaticMeshPath);
+                if (!StaticMesh && !StaticMeshPath.StartsWith(TEXT("StaticMesh'")))
+                {
+                    StaticMesh = LoadObject<UStaticMesh>(nullptr, *FString::Printf(TEXT("StaticMesh'%s'"), *StaticMeshPath));
+                }
+
+                if (!StaticMesh)
+                {
+                    return FUnrealMCPCommonUtils::CreateErrorResponse(
+                        FString::Printf(TEXT("Static mesh not found: %s"), *StaticMeshPath));
+                }
+
+                AStaticMeshActor* StaticMeshActor = Cast<AStaticMeshActor>(NewActor);
+                if (!StaticMeshActor || !StaticMeshActor->GetStaticMeshComponent())
+                {
+                    return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Spawned StaticMeshActor has no StaticMeshComponent."));
+                }
+
+                StaticMeshActor->GetStaticMeshComponent()->SetStaticMesh(StaticMesh);
+                StaticMeshActor->GetStaticMeshComponent()->MarkRenderStateDirty();
+            }
+        }
+    }
+    else if (ActorType == TEXT("PointLight"))
+    {
+        NewActor = World->SpawnActor<APointLight>(APointLight::StaticClass(), Location, Rotation, SpawnParams);
+    }
+    else if (ActorType == TEXT("SpotLight"))
+    {
+        NewActor = World->SpawnActor<ASpotLight>(ASpotLight::StaticClass(), Location, Rotation, SpawnParams);
+    }
+    else if (ActorType == TEXT("DirectionalLight"))
+    {
+        NewActor = World->SpawnActor<ADirectionalLight>(ADirectionalLight::StaticClass(), Location, Rotation, SpawnParams);
+    }
+    else if (ActorType == TEXT("CameraActor"))
+    {
+        NewActor = World->SpawnActor<ACameraActor>(ACameraActor::StaticClass(), Location, Rotation, SpawnParams);
+    }
+    else
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Unknown actor type: %s"), *ActorType));
+    }
+
+    if (NewActor)
+    {
+        // Set scale (since SpawnActor only takes location and rotation)
+        FTransform Transform = NewActor->GetTransform();
+        Transform.SetScale3D(Scale);
+        NewActor->SetActorTransform(Transform);
+
+        // Return the created actor's details
+        return FUnrealMCPCommonUtils::ActorToJsonObject(NewActor, true);
+    }
+
+    return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to create actor"));
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleDeleteActor(const TSharedPtr<FJsonObject>& Params)
+{
+    {
+        FString Err;
+        if (!IsSafeToModifyEditorWorld(Err))
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(Err);
+        }
+    }
+
+    FString ActorName;
+    if (!Params->TryGetStringField(TEXT("name"), ActorName))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'name' parameter"));
+    }
+
+    TArray<AActor*> AllActors;
+    UGameplayStatics::GetAllActorsOfClass(GWorld, AActor::StaticClass(), AllActors);
+    
+    for (AActor* Actor : AllActors)
+    {
+        if (Actor && Actor->GetName() == ActorName)
+        {
+            // Store actor info before deletion for the response
+            TSharedPtr<FJsonObject> ActorInfo = FUnrealMCPCommonUtils::ActorToJsonObject(Actor);
+            
+            // Delete the actor
+            Actor->Destroy();
+            
+            TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+            ResultObj->SetObjectField(TEXT("deleted_actor"), ActorInfo);
+            return ResultObj;
+        }
+    }
+    
+    return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Actor not found: %s"), *ActorName));
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSetActorTransform(const TSharedPtr<FJsonObject>& Params)
+{
+    {
+        FString Err;
+        if (!IsSafeToModifyEditorWorld(Err))
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(Err);
+        }
+    }
+
+    // Get actor name
+    FString ActorName;
+    if (!Params->TryGetStringField(TEXT("name"), ActorName))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'name' parameter"));
+    }
+
+    // Find the actor
+    AActor* TargetActor = nullptr;
+    TArray<AActor*> AllActors;
+    UGameplayStatics::GetAllActorsOfClass(GWorld, AActor::StaticClass(), AllActors);
+    
+    for (AActor* Actor : AllActors)
+    {
+        if (Actor && Actor->GetName() == ActorName)
+        {
+            TargetActor = Actor;
+            break;
+        }
+    }
+
+    if (!TargetActor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Actor not found: %s"), *ActorName));
+    }
+
+    // Get transform parameters
+    FTransform NewTransform = TargetActor->GetTransform();
+
+    if (Params->HasField(TEXT("location")))
+    {
+        NewTransform.SetLocation(FUnrealMCPCommonUtils::GetVectorFromJson(Params, TEXT("location")));
+    }
+    if (Params->HasField(TEXT("rotation")))
+    {
+        NewTransform.SetRotation(FQuat(FUnrealMCPCommonUtils::GetRotatorFromJson(Params, TEXT("rotation"))));
+    }
+    if (Params->HasField(TEXT("scale")))
+    {
+        NewTransform.SetScale3D(FUnrealMCPCommonUtils::GetVectorFromJson(Params, TEXT("scale")));
+    }
+
+    // Set the new transform
+    TargetActor->SetActorTransform(NewTransform);
+
+    // Return updated actor info
+    return FUnrealMCPCommonUtils::ActorToJsonObject(TargetActor, true);
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleGetActorProperties(const TSharedPtr<FJsonObject>& Params)
+{
+    // Get actor name
+    FString ActorName;
+    if (!Params->TryGetStringField(TEXT("name"), ActorName))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'name' parameter"));
+    }
+
+    // Find the actor
+    AActor* TargetActor = nullptr;
+    TArray<AActor*> AllActors;
+    UGameplayStatics::GetAllActorsOfClass(GWorld, AActor::StaticClass(), AllActors);
+    
+    for (AActor* Actor : AllActors)
+    {
+        if (Actor && Actor->GetName() == ActorName)
+        {
+            TargetActor = Actor;
+            break;
+        }
+    }
+
+    if (!TargetActor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Actor not found: %s"), *ActorName));
+    }
+
+    // Always return detailed properties for this command
+    return FUnrealMCPCommonUtils::ActorToJsonObject(TargetActor, true);
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSetActorProperty(const TSharedPtr<FJsonObject>& Params)
+{
+    {
+        FString Err;
+        if (!IsSafeToModifyEditorWorld(Err))
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(Err);
+        }
+    }
+
+    // Get actor name
+    FString ActorName;
+    if (!Params->TryGetStringField(TEXT("name"), ActorName))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'name' parameter"));
+    }
+
+    // Find the actor
+    AActor* TargetActor = nullptr;
+    TArray<AActor*> AllActors;
+    UGameplayStatics::GetAllActorsOfClass(GWorld, AActor::StaticClass(), AllActors);
+    
+    for (AActor* Actor : AllActors)
+    {
+        if (Actor && Actor->GetName() == ActorName)
+        {
+            TargetActor = Actor;
+            break;
+        }
+    }
+
+    if (!TargetActor)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Actor not found: %s"), *ActorName));
+    }
+
+    // Get property name
+    FString PropertyName;
+    if (!Params->TryGetStringField(TEXT("property_name"), PropertyName))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'property_name' parameter"));
+    }
+
+    // Get property value
+    if (!Params->HasField(TEXT("property_value")))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'property_value' parameter"));
+    }
+    
+    TSharedPtr<FJsonValue> PropertyValue = Params->Values.FindRef(TEXT("property_value"));
+    
+    // Set the property using our utility function
+    FString ErrorMessage;
+    if (FUnrealMCPCommonUtils::SetObjectProperty(TargetActor, PropertyName, PropertyValue, ErrorMessage))
+    {
+        // Property set successfully
+        TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+        ResultObj->SetStringField(TEXT("actor"), ActorName);
+        ResultObj->SetStringField(TEXT("property"), PropertyName);
+        ResultObj->SetBoolField(TEXT("success"), true);
+        
+        // Also include the full actor details
+        ResultObj->SetObjectField(TEXT("actor_details"), FUnrealMCPCommonUtils::ActorToJsonObject(TargetActor, true));
+        return ResultObj;
+    }
+    else
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(ErrorMessage);
+    }
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSpawnBlueprintActor(const TSharedPtr<FJsonObject>& Params)
+{
+    {
+        FString Err;
+        if (!IsSafeToModifyEditorWorld(Err))
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(Err);
+        }
+    }
+
+    // Get required parameters
+    FString BlueprintName;
+    if (!Params->TryGetStringField(TEXT("blueprint_name"), BlueprintName))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'blueprint_name' parameter"));
+    }
+
+    FString ActorName;
+    if (!Params->TryGetStringField(TEXT("actor_name"), ActorName))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'actor_name' parameter"));
+    }
+
+    // Find the blueprint
+    if (BlueprintName.IsEmpty())
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Blueprint name is empty"));
+    }
+
+    FString Root      = TEXT("/Game/Blueprints/");
+    FString AssetPath = Root + BlueprintName;
+
+    if (!FPackageName::DoesPackageExist(AssetPath))
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Blueprint '%s' not found – it must reside under /Game/Blueprints"), *BlueprintName));
+    }
+
+    UBlueprint* Blueprint = LoadObject<UBlueprint>(nullptr, *AssetPath);
+    if (!Blueprint)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Blueprint not found: %s"), *BlueprintName));
+    }
+
+    // Get transform parameters
+    FVector Location(0.0f, 0.0f, 0.0f);
+    FRotator Rotation(0.0f, 0.0f, 0.0f);
+    FVector Scale(1.0f, 1.0f, 1.0f);
+
+    if (Params->HasField(TEXT("location")))
+    {
+        Location = FUnrealMCPCommonUtils::GetVectorFromJson(Params, TEXT("location"));
+    }
+    if (Params->HasField(TEXT("rotation")))
+    {
+        Rotation = FUnrealMCPCommonUtils::GetRotatorFromJson(Params, TEXT("rotation"));
+    }
+    if (Params->HasField(TEXT("scale")))
+    {
+        Scale = FUnrealMCPCommonUtils::GetVectorFromJson(Params, TEXT("scale"));
+    }
+
+    // Spawn the actor
+    UWorld* World = GEditor->GetEditorWorldContext().World();
+    if (!World)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to get editor world"));
+    }
+
+    FTransform SpawnTransform;
+    SpawnTransform.SetLocation(Location);
+    SpawnTransform.SetRotation(FQuat(Rotation));
+    SpawnTransform.SetScale3D(Scale);
+
+    FActorSpawnParameters SpawnParams;
+    SpawnParams.Name = *ActorName;
+
+    AActor* NewActor = World->SpawnActor<AActor>(Blueprint->GeneratedClass, SpawnTransform, SpawnParams);
+    if (NewActor)
+    {
+        return FUnrealMCPCommonUtils::ActorToJsonObject(NewActor, true);
+    }
+
+    return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to spawn blueprint actor"));
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleFocusViewport(const TSharedPtr<FJsonObject>& Params)
+{
+    // Get target actor name if provided
+    FString TargetActorName;
+    bool HasTargetActor = Params->TryGetStringField(TEXT("target"), TargetActorName);
+
+    // Get location if provided
+    FVector Location(0.0f, 0.0f, 0.0f);
+    bool HasLocation = false;
+    if (Params->HasField(TEXT("location")))
+    {
+        Location = FUnrealMCPCommonUtils::GetVectorFromJson(Params, TEXT("location"));
+        HasLocation = true;
+    }
+
+    // Get distance
+    float Distance = 1000.0f;
+    if (Params->HasField(TEXT("distance")))
+    {
+        Distance = Params->GetNumberField(TEXT("distance"));
+    }
+
+    // Get orientation if provided
+    FRotator Orientation(0.0f, 0.0f, 0.0f);
+    bool HasOrientation = false;
+    if (Params->HasField(TEXT("orientation")))
+    {
+        Orientation = FUnrealMCPCommonUtils::GetRotatorFromJson(Params, TEXT("orientation"));
+        HasOrientation = true;
+    }
+
+    // Get the active viewport
+    FLevelEditorViewportClient* ViewportClient = (FLevelEditorViewportClient*)GEditor->GetActiveViewport()->GetClient();
+    if (!ViewportClient)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to get active viewport"));
+    }
+
+    // If we have a target actor, focus on it
+    if (HasTargetActor)
+    {
+        // Find the actor
+        AActor* TargetActor = nullptr;
+        TArray<AActor*> AllActors;
+        UGameplayStatics::GetAllActorsOfClass(GWorld, AActor::StaticClass(), AllActors);
+        
+        for (AActor* Actor : AllActors)
+        {
+            if (Actor && Actor->GetName() == TargetActorName)
+            {
+                TargetActor = Actor;
+                break;
+            }
+        }
+
+        if (!TargetActor)
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Actor not found: %s"), *TargetActorName));
+        }
+
+        // Focus on the actor
+        ViewportClient->SetViewLocation(TargetActor->GetActorLocation() - FVector(Distance, 0.0f, 0.0f));
+    }
+    // Otherwise use the provided location
+    else if (HasLocation)
+    {
+        ViewportClient->SetViewLocation(Location - FVector(Distance, 0.0f, 0.0f));
+    }
+    else
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Either 'target' or 'location' must be provided"));
+    }
+
+    // Set orientation if provided
+    if (HasOrientation)
+    {
+        ViewportClient->SetViewRotation(Orientation);
+    }
+
+    // Force viewport to redraw
+    ViewportClient->Invalidate();
+
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetBoolField(TEXT("success"), true);
+    return ResultObj;
+}
+
+TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleTakeScreenshot(const TSharedPtr<FJsonObject>& Params)
+{
+    // Optional file path parameter.
+    // If omitted, save to <Project>/Saved/Screenshots/Flockbay with an auto-generated filename.
+    FString FilePath;
+    const bool bHasFilePath = Params->TryGetStringField(TEXT("filepath"), FilePath);
+
+    FString FileName;
+    Params->TryGetStringField(TEXT("filename"), FileName);
+    
+    const FString DefaultDir = FPaths::Combine(FPaths::ProjectSavedDir(), TEXT("Screenshots"), TEXT("Flockbay"));
+    IFileManager::Get().MakeDirectory(*DefaultDir, /*Tree*/ true);
+
+    if (bHasFilePath)
+    {
+        FilePath = FilePath.TrimStartAndEnd();
+        if (FilePath.IsEmpty())
+        {
+            FilePath.Reset();
+        }
+        else if (!FPaths::IsRelative(FilePath))
+        {
+            // absolute path: use as-is
+        }
+        else
+        {
+            // relative path: resolve under our default screenshots folder
+            FilePath = FPaths::Combine(DefaultDir, FilePath);
+        }
+    }
+
+    if (FilePath.IsEmpty())
+    {
+        if (FileName.IsEmpty())
+        {
+            FileName = FString::Printf(TEXT("mcp_screenshot_%s"), *FDateTime::Now().ToString(TEXT("%Y%m%d_%H%M%S")));
+        }
+        FilePath = FPaths::Combine(DefaultDir, FileName);
+    }
+
+    // Ensure the file path has a proper extension
+    if (!FilePath.EndsWith(TEXT(".png")))
+    {
+        FilePath += TEXT(".png");
+    }
+
+    // Get the active viewport
+    if (GEditor && GEditor->GetActiveViewport())
+    {
+        FViewport* Viewport = GEditor->GetActiveViewport();
+        TArray<FColor> Bitmap;
+        FIntRect ViewportRect(0, 0, Viewport->GetSizeXY().X, Viewport->GetSizeXY().Y);
+        
+        if (Viewport->ReadPixels(Bitmap, FReadSurfaceDataFlags(), ViewportRect))
+        {
+            TArray<uint8> CompressedBitmap;
+            FImageUtils::CompressImageArray(Viewport->GetSizeXY().X, Viewport->GetSizeXY().Y, Bitmap, CompressedBitmap);
+            
+            if (FFileHelper::SaveArrayToFile(CompressedBitmap, *FilePath))
+            {
+                TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+                ResultObj->SetStringField(TEXT("filepath"), FilePath);
+                return ResultObj;
+            }
+        }
+    }
+    
+    return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to take screenshot"));
+}