flockbay 0.10.15

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Public/Commands/UnrealMCPUMGCommands.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Json.h"
+
+/**
+ * Handles UMG (Widget Blueprint) related MCP commands
+ * Responsible for creating and modifying UMG Widget Blueprints,
+ * adding widget components, and managing widget instances in the viewport.
+ */
+class UNREALMCP_API FUnrealMCPUMGCommands
+{
+public:
+    FUnrealMCPUMGCommands();
+
+    /**
+     * Handle UMG-related commands
+     * @param CommandType - The type of command to handle
+     * @param Params - JSON parameters for the command
+     * @return JSON response with results or error
+     */
+    TSharedPtr<FJsonObject> HandleCommand(const FString& CommandType, const TSharedPtr<FJsonObject>& Params);
+
+private:
+    /**
+     * Create a new UMG Widget Blueprint
+     * @param Params - Must include "name" for the blueprint name
+     * @return JSON response with the created blueprint details
+     */
+    TSharedPtr<FJsonObject> HandleCreateUMGWidgetBlueprint(const TSharedPtr<FJsonObject>& Params);
+
+    /**
+     * Add a Text Block widget to a UMG Widget Blueprint
+     * @param Params - Must include:
+     *                "blueprint_name" - Name of the target Widget Blueprint
+     *                "widget_name" - Name for the new Text Block
+     *                "text" - Initial text content (optional)
+     *                "position" - [X, Y] position in the canvas (optional)
+     * @return JSON response with the added widget details
+     */
+    TSharedPtr<FJsonObject> HandleAddTextBlockToWidget(const TSharedPtr<FJsonObject>& Params);
+
+    /**
+     * Add a widget instance to the game viewport
+     * @param Params - Must include:
+     *                "blueprint_name" - Name of the Widget Blueprint to instantiate
+     *                "z_order" - Z-order for widget display (optional)
+     * @return JSON response with the widget instance details
+     */
+    TSharedPtr<FJsonObject> HandleAddWidgetToViewport(const TSharedPtr<FJsonObject>& Params);
+
+    /**
+     * Add a Button widget to a UMG Widget Blueprint
+     * @param Params - Must include:
+     *                "blueprint_name" - Name of the target Widget Blueprint
+     *                "widget_name" - Name for the new Button
+     *                "text" - Button text
+     *                "position" - [X, Y] position in the canvas
+     * @return JSON response with the added widget details
+     */
+    TSharedPtr<FJsonObject> HandleAddButtonToWidget(const TSharedPtr<FJsonObject>& Params);
+
+    /**
+     * Bind an event to a widget (e.g. button click)
+     * @param Params - Must include:
+     *                "blueprint_name" - Name of the target Widget Blueprint
+     *                "widget_name" - Name of the widget to bind
+     *                "event_name" - Name of the event to bind
+     * @return JSON response with the binding details
+     */
+    TSharedPtr<FJsonObject> HandleBindWidgetEvent(const TSharedPtr<FJsonObject>& Params);
+
+    /**
+     * Set up text block binding for dynamic updates
+     * @param Params - Must include:
+     *                "blueprint_name" - Name of the target Widget Blueprint
+     *                "widget_name" - Name of the widget to bind
+     *                "binding_name" - Name of the binding to set up
+     * @return JSON response with the binding details
+     */
+    TSharedPtr<FJsonObject> HandleSetTextBlockBinding(const TSharedPtr<FJsonObject>& Params);
+}; 

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Public/MCPServerRunnable.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "HAL/Runnable.h"
+#include "Sockets.h"
+#include "Interfaces/IPv4/IPv4Address.h"
+
+class UUnrealMCPBridge;
+
+/**
+ * Runnable class for the MCP server thread
+ */
+class FMCPServerRunnable : public FRunnable
+{
+public:
+	FMCPServerRunnable(UUnrealMCPBridge* InBridge, TSharedPtr<FSocket> InListenerSocket);
+	virtual ~FMCPServerRunnable();
+
+	// FRunnable interface
+	virtual bool Init() override;
+	virtual uint32 Run() override;
+	virtual void Stop() override;
+	virtual void Exit() override;
+
+protected:
+	void HandleClientConnection(TSharedPtr<FSocket> ClientSocket);
+	void ProcessMessage(TSharedPtr<FSocket> Client, const FString& Message);
+
+private:
+	UUnrealMCPBridge* Bridge;
+	TSharedPtr<FSocket> ListenerSocket;
+	TSharedPtr<FSocket> ClientSocket;
+	bool bRunning;
+}; 

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Public/UnrealMCPBridge.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "EditorSubsystem.h"
+#include "Sockets.h"
+#include "SocketSubsystem.h"
+#include "Http.h"
+#include "Json.h"
+#include "Interfaces/IPv4/IPv4Address.h"
+#include "Interfaces/IPv4/IPv4Endpoint.h"
+#include "Commands/UnrealMCPEditorCommands.h"
+#include "Commands/UnrealMCPBlueprintCommands.h"
+#include "Commands/UnrealMCPBlueprintNodeCommands.h"
+#include "Commands/UnrealMCPProjectCommands.h"
+#include "Commands/UnrealMCPUMGCommands.h"
+#include "UnrealMCPBridge.generated.h"
+
+class FMCPServerRunnable;
+
+/**
+ * Editor subsystem for MCP Bridge
+ * Handles communication between external tools and the Unreal Editor
+ * through a TCP socket connection. Commands are received as JSON and
+ * routed to appropriate command handlers.
+ */
+UCLASS()
+class UNREALMCP_API UUnrealMCPBridge : public UEditorSubsystem
+{
+	GENERATED_BODY()
+
+public:
+	UUnrealMCPBridge();
+	virtual ~UUnrealMCPBridge();
+
+	// UEditorSubsystem implementation
+	virtual void Initialize(FSubsystemCollectionBase& Collection) override;
+	virtual void Deinitialize() override;
+
+	// Server functions
+	void StartServer();
+	void StopServer();
+	bool IsRunning() const { return bIsRunning; }
+
+	// Command execution
+	FString ExecuteCommand(const FString& CommandType, const TSharedPtr<FJsonObject>& Params);
+
+private:
+	// Server state
+	bool bIsRunning;
+	TSharedPtr<FSocket> ListenerSocket;
+	TSharedPtr<FSocket> ConnectionSocket;
+	FRunnableThread* ServerThread;
+
+	// Server configuration
+	FIPv4Address ServerAddress;
+	uint16 Port;
+
+	// Command handler instances
+	TSharedPtr<FUnrealMCPEditorCommands> EditorCommands;
+	TSharedPtr<FUnrealMCPBlueprintCommands> BlueprintCommands;
+	TSharedPtr<FUnrealMCPBlueprintNodeCommands> BlueprintNodeCommands;
+	TSharedPtr<FUnrealMCPProjectCommands> ProjectCommands;
+	TSharedPtr<FUnrealMCPUMGCommands> UMGCommands;
+}; 

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Public/UnrealMCPModule.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Modules/ModuleManager.h"
+
+class FUnrealMCPModule : public IModuleInterface
+{
+public:
+	/** IModuleInterface implementation */
+	virtual void StartupModule() override;
+	virtual void ShutdownModule() override;
+
+	static inline FUnrealMCPModule& Get()
+	{
+		return FModuleManager::LoadModuleChecked<FUnrealMCPModule>("UnrealMCP");
+	}
+
+	static inline bool IsAvailable()
+	{
+		return FModuleManager::Get().IsModuleLoaded("UnrealMCP");
+	}
+}; 

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/UnrealMCP.Build.cs

@@ -0,0 +1,78 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+using UnrealBuildTool;
+
+public class UnrealMCP : ModuleRules
+{
+	public UnrealMCP(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+		// Use IWYUSupport instead of the deprecated bEnforceIWYU in UE5.5
+		IWYUSupport = IWYUSupport.Full;
+
+		PublicIncludePaths.AddRange(
+			new string[] {
+				// ... add public include paths required here ...
+			}
+		);
+		
+		PrivateIncludePaths.AddRange(
+			new string[] {
+				// ... add other private include paths required here ...
+			}
+		);
+		
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				"CoreUObject",
+				"Engine",
+				"InputCore",
+				"Networking",
+				"Sockets",
+				"HTTP",
+				"Json",
+				"JsonUtilities",
+				"DeveloperSettings"
+			}
+		);
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"UnrealEd",
+				"EditorScriptingUtilities",
+				"EditorSubsystem",
+				"Slate",
+				"SlateCore",
+				"UMG",
+				"Kismet",
+				"KismetCompiler",
+				"BlueprintGraph",
+				"Projects",
+				"AssetRegistry"
+			}
+		);
+		
+		if (Target.bBuildEditor == true)
+		{
+			PrivateDependencyModuleNames.AddRange(
+				new string[]
+				{
+					"PropertyEditor",      // For widget property editing
+					"ToolMenus",           // For editor UI
+					"BlueprintEditorLibrary", // For Blueprint utilities
+					"UMGEditor"           // For WidgetBlueprint.h and other UMG editor functionality
+				}
+			);
+		}
+		
+		DynamicallyLoadedModuleNames.AddRange(
+			new string[]
+			{
+				// ... add any modules that your module loads dynamically here ...
+			}
+		);
+	}
+} 

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/UnrealMCP.uplugin

@@ -0,0 +1,36 @@
+{
+	"FileVersion": 3,
+	"Version": 1,
+	"VersionName": "1.0",
+	"FriendlyName": "Flockbay MCP",
+	"Description": "Flockbay bridge for Unreal Editor via Model Context Protocol (MCP)",
+	"Category": "Editor",
+	"CreatedBy": "Respaced Inc.",
+	"CreatedByURL": "",
+	"DocsURL": "",
+	"MarketplaceURL": "",
+	"SupportURL": "",
+	"CanContainContent": true,
+	"IsBetaVersion": false,
+	"IsExperimentalVersion": false,
+	"EnabledByDefault": false,
+	"Installed": false,
+	"Modules": [
+		{
+			"Name": "UnrealMCP",
+			"Type": "Editor",
+			"LoadingPhase": "Default",
+			"WhitelistPlatforms": [
+				"Win64",
+				"Mac",
+				"Linux"
+			]
+		}
+	],
+	"Plugins": [
+		{
+			"Name": "EditorScriptingUtilities",
+			"Enabled": true
+		}
+	]
+} 

package/tools/unreal-mcp/upstream/Python/README.md

@@ -0,0 +1,40 @@
+# Unreal MCP
+
+Python bridge for interacting with Unreal Engine 5.5 using the Model Context Protocol (MCP).
+
+## Setup
+
+1. Make sure Python 3.10+ is installed
+2. Install `uv` if you haven't already:
+   ```bash
+   curl -LsSf https://astral.sh/uv/install.sh | sh
+   ```
+3. Create and activate a virtual environment:
+   ```bash
+   uv venv
+   source .venv/bin/activate  # On Unix/macOS
+   # or
+   .venv\Scripts\activate     # On Windows
+   ```
+4. Install dependencies:
+   ```bash
+   uv pip install -e .
+   ```
+
+At this point, you can configure your MCP Client (Claude Desktop, Cursor, Windsurf) to use the Unreal MCP Server as per the [Configuring your MCP Client](README.md#configuring-your-mcp-client).
+
+## Testing Scripts
+
+There are several scripts in the [scripts](./scripts) folder. They are useful for testing the tools and the Unreal Bridge via a direct connection. This means that you do not need to have an MCP Server running.
+
+You should make sure you have installed dependencies and/or are running in the `uv` virtual environment in order for the scripts to work.
+
+
+## Troubleshooting
+
+- Make sure Unreal Engine editor is loaded loaded and running before running the server.
+- Check logs in `unreal_mcp.log` for detailed error information
+
+## Development
+
+To add new tools, modify the `UnrealMCPBridge.py` file to add new command handlers, and update the `unreal_mcp_server.py` file to expose them through the HTTP API. 

package/tools/unreal-mcp/upstream/Python/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "unreal-mcp"
+version = "0.1.0"
+description = "Unreal MCP Server: A server for Unreal Engine integration via the Model Context Protocol (MCP)."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "mcp[cli]>=1.4.1",
+  "fastmcp>=0.2.0",
+  "uvicorn",
+  "fastapi",
+  "pydantic>=2.6.1",
+  "requests"
+]
+
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+# The main server script is a single-file module
+py-modules = ["unreal_mcp_server"] 

package/tools/unreal-mcp/upstream/Python/scripts/actors/test_cube.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python
+"""
+Test script for creating and manipulating actors in Unreal Engine via MCP.
+
+This script demonstrates the basic actor manipulation capabilities of the MCP system:
+- Creating actors with specific names and transforms
+- Getting actor properties
+- Modifying actor transforms
+- Error handling and validation
+"""
+
+import sys
+import os
+import time
+import socket
+import json
+import logging
+from typing import Dict, Any, Optional
+
+# Add the parent directory to the path so we can import the server module
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("TestCube")
+
+def send_command(command: str, params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Send a command to the Unreal MCP server and get the response.
+    
+    Args:
+        command: The command type to send
+        params: Dictionary of parameters for the command
+        
+    Returns:
+        Optional[Dict[str, Any]]: The response from the server, or None if there was an error
+    """
+    try:
+        # Create new socket connection
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.connect(("127.0.0.1", 55557))
+        
+        try:
+            # Create command object
+            command_obj = {
+                "type": command,
+                "params": params
+            }
+            
+            # Convert to JSON and send
+            command_json = json.dumps(command_obj)
+            logger.info(f"Sending command: {command_json}")
+            sock.sendall(command_json.encode('utf-8'))
+            
+            # Receive response
+            chunks = []
+            while True:
+                chunk = sock.recv(4096)
+                if not chunk:
+                    break
+                chunks.append(chunk)
+                
+                # Try parsing to see if we have a complete response
+                try:
+                    data = b''.join(chunks)
+                    json.loads(data.decode('utf-8'))
+                    # If we can parse it, we have the complete response
+                    break
+                except json.JSONDecodeError:
+                    # Not a complete JSON object yet, continue receiving
+                    continue
+            
+            # Parse response
+            data = b''.join(chunks)
+            response = json.loads(data.decode('utf-8'))
+            logger.info(f"Received response: {response}")
+            return response
+            
+        finally:
+            # Always close the socket
+            sock.close()
+            
+    except Exception as e:
+        logger.error(f"Error sending command: {e}")
+        return None
+
+def create_test_cube(name: str, location: list[float]) -> Optional[Dict[str, Any]]:
+    """Create a test cube actor with the specified name and location.
+    
+    Args:
+        name: The name to give the cube actor
+        location: The [x, y, z] world location to spawn at
+        
+    Returns:
+        Optional[Dict[str, Any]]: The response from the create command, or None if failed
+    """
+    cube_params = {
+        "name": name,
+        "type": "StaticMeshActor",
+        "location": location,
+        "rotation": [0.0, 0.0, 0.0],
+        "scale": [1.0, 1.0, 1.0]
+    }
+    
+    response = send_command("create_actor", cube_params)
+    if not response or response.get("status") != "success":
+        logger.error(f"Failed to create cube: {response}")
+        return None
+        
+    logger.info(f"Created cube '{name}' successfully at location {location}")
+    return response
+
+def get_actor_properties(name: str) -> Optional[Dict[str, Any]]:
+    """Get the properties of an actor by name.
+    
+    Args:
+        name: The name of the actor to get properties for
+        
+    Returns:
+        Optional[Dict[str, Any]]: The actor properties, or None if not found/error
+    """
+    response = send_command("get_actor_properties", {"name": name})
+    if not response or response.get("status") != "success":
+        logger.error(f"Failed to get properties for actor '{name}': {response}")
+        return None
+        
+    logger.info(f"Got properties for actor '{name}' successfully")
+    return response
+
+def set_actor_transform(
+    name: str,
+    location: Optional[list[float]] = None,
+    rotation: Optional[list[float]] = None,
+    scale: Optional[list[float]] = None
+) -> Optional[Dict[str, Any]]:
+    """Set the transform of an actor.
+    
+    Args:
+        name: The name of the actor to modify
+        location: Optional new [x, y, z] location
+        rotation: Optional new [pitch, yaw, roll] rotation in degrees
+        scale: Optional new [x, y, z] scale
+        
+    Returns:
+        Optional[Dict[str, Any]]: The updated actor properties, or None if failed
+    """
+    transform_params = {"name": name}
+    if location is not None:
+        transform_params["location"] = location
+    if rotation is not None:
+        transform_params["rotation"] = rotation
+    if scale is not None:
+        transform_params["scale"] = scale
+        
+    response = send_command("set_actor_transform", transform_params)
+    if not response or response.get("status") != "success":
+        logger.error(f"Failed to set transform for actor '{name}': {response}")
+        return None
+        
+    logger.info(f"Modified transform for actor '{name}' successfully")
+    return response
+
+def main():
+    """Main function to test actor creation and manipulation."""
+    try:
+        # Create first test cube
+        cube1_name = "TestCube_001"
+        cube1 = create_test_cube(cube1_name, [0.0, 0.0, 100.0])
+        if not cube1:
+            logger.error("Failed to create first test cube")
+            return
+            
+        # Get its properties to verify creation
+        props = get_actor_properties(cube1_name)
+        if not props:
+            logger.error("Failed to verify first test cube properties")
+            return
+            
+        # Modify its transform
+        result = set_actor_transform(
+            cube1_name,
+            location=[0.0, 0.0, 200.0],
+            rotation=[0.0, 45.0, 0.0],
+            scale=[2.0, 2.0, 2.0]
+        )
+        if not result:
+            logger.error("Failed to modify first test cube transform")
+            return
+            
+        # Create a second test cube at a different location
+        cube2_name = "TestCube_002"
+        cube2 = create_test_cube(cube2_name, [100.0, 100.0, 100.0])
+        if not cube2:
+            logger.error("Failed to create second test cube")
+            return
+            
+        logger.info("All test operations completed successfully!")
+        
+    except Exception as e:
+        logger.error(f"Error in main: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()