ue-mcp 0.4.0-alpha

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/MaterialHandlers.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Dom/JsonValue.h"
+#include "Dom/JsonObject.h"
+
+class FMaterialHandlers
+{
+public:
+	static void RegisterHandlers(class FMCPHandlerRegistry& Registry);
+
+private:
+	static TSharedPtr<FJsonValue> ListExpressionTypes(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> CreateMaterial(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> ReadMaterial(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetMaterialShadingModel(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetMaterialBlendMode(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetMaterialBaseColor(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> AddMaterialExpression(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> ListMaterialExpressions(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> ListMaterialParameters(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> RecompileMaterial(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> CreateMaterialInstance(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetMaterialParameter(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> ConnectExpression(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> ConnectMaterialProperty(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> DeleteExpression(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetExpressionValue(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> CreateMaterialFromTexture(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> ReadMaterialInstance(const TSharedPtr<FJsonObject>& Params);
+
+	// Name-based handlers matching TS tool expectations
+	static TSharedPtr<FJsonValue> ConnectTextureToMaterial(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> ConnectMaterialExpressions(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> ConnectToMaterialProperty(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> DeleteMaterialExpression(const TSharedPtr<FJsonObject>& Params);
+
+	// Helper to load a UMaterial from an asset path
+	static UMaterial* LoadMaterialFromPath(const FString& AssetPath);
+
+	// Helper to load a UMaterialInstanceConstant from an asset path
+	static UMaterialInstanceConstant* LoadMaterialInstanceFromPath(const FString& AssetPath);
+
+	// Helper to convert shading model string to enum
+	static EMaterialShadingModel ParseShadingModel(const FString& ShadingModelStr);
+	static FString ShadingModelToString(EMaterialShadingModel ShadingModel);
+
+	// Helper to map material property name string to EMaterialProperty enum
+	static bool ParseMaterialProperty(const FString& PropertyName, EMaterialProperty& OutProperty);
+
+	// Helper to find an expression by name (description or class) within a material
+	static UMaterialExpression* FindExpressionByName(UMaterial* Material, const FString& ExpressionName);
+};

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/NetworkingHandlers.cpp

@@ -0,0 +1,554 @@
+#include "NetworkingHandlers.h"
+#include "HandlerRegistry.h"
+#include "Engine/Blueprint.h"
+#include "GameFramework/Actor.h"
+#include "Kismet2/KismetEditorUtilities.h"
+#include "Kismet2/BlueprintEditorUtils.h"
+#include "UObject/UObjectGlobals.h"
+#include "UObject/Package.h"
+#include "Misc/PackageName.h"
+#include "UObject/SavePackage.h"
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+#include "UObject/UnrealType.h"
+#include "EditorScriptingUtilities/Public/EditorAssetLibrary.h"
+
+void FNetworkingHandlers::RegisterHandlers(FMCPHandlerRegistry& Registry)
+{
+	Registry.RegisterHandler(TEXT("get_networking_info"), &GetNetworkingInfo);
+	Registry.RegisterHandler(TEXT("set_replicates"), &SetReplicates);
+	Registry.RegisterHandler(TEXT("configure_net_update_frequency"), &ConfigureNetUpdateFrequency);
+	Registry.RegisterHandler(TEXT("set_net_dormancy"), &SetNetDormancy);
+	Registry.RegisterHandler(TEXT("set_always_relevant"), &SetAlwaysRelevant);
+	Registry.RegisterHandler(TEXT("set_net_priority"), &SetNetPriority);
+	Registry.RegisterHandler(TEXT("set_replicate_movement"), &SetReplicateMovement);
+	Registry.RegisterHandler(TEXT("set_variable_replication"), &SetVariableReplication);
+	Registry.RegisterHandler(TEXT("get_replication_info"), &GetReplicationInfo);
+	Registry.RegisterHandler(TEXT("set_owner_only_relevant"), &SetOwnerOnlyRelevant);
+
+	// Aliases
+	Registry.RegisterHandler(TEXT("set_property_replicated"), &SetVariableReplication);
+	Registry.RegisterHandler(TEXT("set_only_relevant_to_owner"), &SetOwnerOnlyRelevant);
+	// New handlers
+	Registry.RegisterHandler(TEXT("set_net_load_on_client"), &SetNetLoadOnClient);
+	Registry.RegisterHandler(TEXT("configure_net_cull_distance"), &ConfigureNetCullDistance);
+}
+
+AActor* FNetworkingHandlers::LoadBlueprintCDO(const FString& BlueprintPath, TSharedPtr<FJsonObject>& OutResult)
+{
+	UBlueprint* Blueprint = LoadObject<UBlueprint>(nullptr, *BlueprintPath);
+	if (!Blueprint || !Blueprint->GeneratedClass)
+	{
+		OutResult->SetStringField(TEXT("error"), FString::Printf(TEXT("Blueprint not found or has no generated class: %s"), *BlueprintPath));
+		OutResult->SetBoolField(TEXT("success"), false);
+		return nullptr;
+	}
+
+	AActor* CDO = Cast<AActor>(Blueprint->GeneratedClass->GetDefaultObject());
+	if (!CDO)
+	{
+		OutResult->SetStringField(TEXT("error"), TEXT("CDO is not an Actor"));
+		OutResult->SetBoolField(TEXT("success"), false);
+		return nullptr;
+	}
+
+	return CDO;
+}
+
+void FNetworkingHandlers::SaveBlueprint(UBlueprint* Blueprint)
+{
+	if (!Blueprint) return;
+	FKismetEditorUtilities::CompileBlueprint(Blueprint);
+	UPackage* Package = Blueprint->GetOutermost();
+	if (Package)
+	{
+		Package->MarkPackageDirty();
+		FString PackageFileName = FPackageName::LongPackageNameToFilename(Package->GetName(), FPackageName::GetAssetPackageExtension());
+		FSavePackageArgs SaveArgs;
+		SaveArgs.TopLevelFlags = RF_Standalone;
+		UPackage::SavePackage(Package, nullptr, *PackageFileName, SaveArgs);
+	}
+}
+
+TSharedPtr<FJsonValue> FNetworkingHandlers::GetNetworkingInfo(const TSharedPtr<FJsonObject>& Params)
+{
+	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+
+	FString BlueprintPath;
+	if (!Params->TryGetStringField(TEXT("blueprintPath"), BlueprintPath))
+	{
+		Result->SetStringField(TEXT("error"), TEXT("Missing 'blueprintPath' parameter"));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	AActor* CDO = LoadBlueprintCDO(BlueprintPath, Result);
+	if (!CDO) return MakeShared<FJsonValueObject>(Result);
+
+	Result->SetStringField(TEXT("blueprintPath"), BlueprintPath);
+	Result->SetBoolField(TEXT("replicates"), CDO->GetIsReplicated());
+	Result->SetNumberField(TEXT("netUpdateFrequency"), CDO->GetNetUpdateFrequency());
+	Result->SetNumberField(TEXT("minNetUpdateFrequency"), CDO->GetMinNetUpdateFrequency());
+	Result->SetNumberField(TEXT("netPriority"), CDO->NetPriority);
+	Result->SetBoolField(TEXT("alwaysRelevant"), CDO->bAlwaysRelevant);
+	Result->SetBoolField(TEXT("replicateMovement"), CDO->IsReplicatingMovement());
+	Result->SetNumberField(TEXT("netDormancy"), (int32)CDO->NetDormancy);
+	Result->SetBoolField(TEXT("success"), true);
+
+	return MakeShared<FJsonValueObject>(Result);
+}
+
+TSharedPtr<FJsonValue> FNetworkingHandlers::SetReplicates(const TSharedPtr<FJsonObject>& Params)
+{
+	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+
+	FString BlueprintPath;
+	if (!Params->TryGetStringField(TEXT("blueprintPath"), BlueprintPath))
+	{
+		Result->SetStringField(TEXT("error"), TEXT("Missing 'blueprintPath' parameter"));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	AActor* CDO = LoadBlueprintCDO(BlueprintPath, Result);
+	if (!CDO) return MakeShared<FJsonValueObject>(Result);
+
+	bool bReplicates = false;
+	Params->TryGetBoolField(TEXT("replicates"), bReplicates);
+	CDO->SetReplicates(bReplicates);
+
+	UBlueprint* Blueprint = LoadObject<UBlueprint>(nullptr, *BlueprintPath);
+	SaveBlueprint(Blueprint);
+
+	Result->SetStringField(TEXT("blueprintPath"), BlueprintPath);
+	Result->SetBoolField(TEXT("replicates"), bReplicates);
+	Result->SetBoolField(TEXT("success"), true);
+	return MakeShared<FJsonValueObject>(Result);
+}
+
+TSharedPtr<FJsonValue> FNetworkingHandlers::ConfigureNetUpdateFrequency(const TSharedPtr<FJsonObject>& Params)
+{
+	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+
+	FString BlueprintPath;
+	if (!Params->TryGetStringField(TEXT("blueprintPath"), BlueprintPath))
+	{
+		Result->SetStringField(TEXT("error"), TEXT("Missing 'blueprintPath' parameter"));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	AActor* CDO = LoadBlueprintCDO(BlueprintPath, Result);
+	if (!CDO) return MakeShared<FJsonValueObject>(Result);
+
+	double NetUpdateFrequency = 0;
+	if (Params->TryGetNumberField(TEXT("netUpdateFrequency"), NetUpdateFrequency))
+	{
+		CDO->SetNetUpdateFrequency((float)NetUpdateFrequency);
+	}
+	double MinNetUpdateFrequency = 0;
+	if (Params->TryGetNumberField(TEXT("minNetUpdateFrequency"), MinNetUpdateFrequency))
+	{
+		CDO->SetMinNetUpdateFrequency((float)MinNetUpdateFrequency);
+	}
+
+	UBlueprint* Blueprint = LoadObject<UBlueprint>(nullptr, *BlueprintPath);
+	SaveBlueprint(Blueprint);
+
+	Result->SetStringField(TEXT("blueprintPath"), BlueprintPath);
+	Result->SetNumberField(TEXT("netUpdateFrequency"), CDO->GetNetUpdateFrequency());
+	Result->SetNumberField(TEXT("minNetUpdateFrequency"), CDO->GetMinNetUpdateFrequency());
+	Result->SetBoolField(TEXT("success"), true);
+	return MakeShared<FJsonValueObject>(Result);
+}
+
+TSharedPtr<FJsonValue> FNetworkingHandlers::SetNetDormancy(const TSharedPtr<FJsonObject>& Params)
+{
+	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+
+	FString BlueprintPath;
+	if (!Params->TryGetStringField(TEXT("blueprintPath"), BlueprintPath))
+	{
+		Result->SetStringField(TEXT("error"), TEXT("Missing 'blueprintPath' parameter"));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	AActor* CDO = LoadBlueprintCDO(BlueprintPath, Result);
+	if (!CDO) return MakeShared<FJsonValueObject>(Result);
+
+	FString Dormancy;
+	if (Params->TryGetStringField(TEXT("dormancy"), Dormancy))
+	{
+		if (Dormancy == TEXT("DORM_Never"))
+			CDO->NetDormancy = DORM_Never;
+		else if (Dormancy == TEXT("DORM_Awake"))
+			CDO->NetDormancy = DORM_Awake;
+		else if (Dormancy == TEXT("DORM_DormantAll"))
+			CDO->NetDormancy = DORM_DormantAll;
+		else if (Dormancy == TEXT("DORM_DormantPartial"))
+			CDO->NetDormancy = DORM_DormantPartial;
+		else if (Dormancy == TEXT("DORM_Initial"))
+			CDO->NetDormancy = DORM_Initial;
+	}
+
+	UBlueprint* Blueprint = LoadObject<UBlueprint>(nullptr, *BlueprintPath);
+	SaveBlueprint(Blueprint);
+
+	Result->SetStringField(TEXT("blueprintPath"), BlueprintPath);
+	Result->SetNumberField(TEXT("netDormancy"), (int32)CDO->NetDormancy);
+	Result->SetBoolField(TEXT("success"), true);
+	return MakeShared<FJsonValueObject>(Result);
+}
+
+TSharedPtr<FJsonValue> FNetworkingHandlers::SetAlwaysRelevant(const TSharedPtr<FJsonObject>& Params)
+{
+	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+
+	FString BlueprintPath;
+	if (!Params->TryGetStringField(TEXT("blueprintPath"), BlueprintPath))
+	{
+		Result->SetStringField(TEXT("error"), TEXT("Missing 'blueprintPath' parameter"));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	AActor* CDO = LoadBlueprintCDO(BlueprintPath, Result);
+	if (!CDO) return MakeShared<FJsonValueObject>(Result);
+
+	bool bAlwaysRelevant = false;
+	Params->TryGetBoolField(TEXT("alwaysRelevant"), bAlwaysRelevant);
+	CDO->bAlwaysRelevant = bAlwaysRelevant;
+
+	UBlueprint* Blueprint = LoadObject<UBlueprint>(nullptr, *BlueprintPath);
+	SaveBlueprint(Blueprint);
+
+	Result->SetStringField(TEXT("blueprintPath"), BlueprintPath);
+	Result->SetBoolField(TEXT("alwaysRelevant"), bAlwaysRelevant);
+	Result->SetBoolField(TEXT("success"), true);
+	return MakeShared<FJsonValueObject>(Result);
+}
+
+TSharedPtr<FJsonValue> FNetworkingHandlers::SetNetPriority(const TSharedPtr<FJsonObject>& Params)
+{
+	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+
+	FString BlueprintPath;
+	if (!Params->TryGetStringField(TEXT("blueprintPath"), BlueprintPath))
+	{
+		Result->SetStringField(TEXT("error"), TEXT("Missing 'blueprintPath' parameter"));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	AActor* CDO = LoadBlueprintCDO(BlueprintPath, Result);
+	if (!CDO) return MakeShared<FJsonValueObject>(Result);
+
+	double NetPriority = 1.0;
+	if (Params->TryGetNumberField(TEXT("netPriority"), NetPriority))
+	{
+		CDO->NetPriority = (float)NetPriority;
+	}
+
+	UBlueprint* Blueprint = LoadObject<UBlueprint>(nullptr, *BlueprintPath);
+	SaveBlueprint(Blueprint);
+
+	Result->SetStringField(TEXT("blueprintPath"), BlueprintPath);
+	Result->SetNumberField(TEXT("netPriority"), CDO->NetPriority);
+	Result->SetBoolField(TEXT("success"), true);
+	return MakeShared<FJsonValueObject>(Result);
+}
+
+TSharedPtr<FJsonValue> FNetworkingHandlers::SetReplicateMovement(const TSharedPtr<FJsonObject>& Params)
+{
+	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+
+	FString BlueprintPath;
+	if (!Params->TryGetStringField(TEXT("blueprintPath"), BlueprintPath))
+	{
+		Result->SetStringField(TEXT("error"), TEXT("Missing 'blueprintPath' parameter"));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	AActor* CDO = LoadBlueprintCDO(BlueprintPath, Result);
+	if (!CDO) return MakeShared<FJsonValueObject>(Result);
+
+	bool bReplicateMovement = false;
+	Params->TryGetBoolField(TEXT("replicateMovement"), bReplicateMovement);
+	CDO->SetReplicatingMovement(bReplicateMovement);
+
+	UBlueprint* Blueprint = LoadObject<UBlueprint>(nullptr, *BlueprintPath);
+	SaveBlueprint(Blueprint);
+
+	Result->SetStringField(TEXT("blueprintPath"), BlueprintPath);
+	Result->SetBoolField(TEXT("replicateMovement"), bReplicateMovement);
+	Result->SetBoolField(TEXT("success"), true);
+	return MakeShared<FJsonValueObject>(Result);
+}
+
+TSharedPtr<FJsonValue> FNetworkingHandlers::SetVariableReplication(const TSharedPtr<FJsonObject>& Params)
+{
+	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+
+	FString BlueprintPath;
+	if (!Params->TryGetStringField(TEXT("blueprintPath"), BlueprintPath))
+	{
+		Result->SetStringField(TEXT("error"), TEXT("Missing 'blueprintPath' parameter"));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	FString VariableName;
+	if (!Params->TryGetStringField(TEXT("variableName"), VariableName))
+	{
+		Result->SetStringField(TEXT("error"), TEXT("Missing 'variableName' parameter"));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	FString ReplicationType = TEXT("None");
+	Params->TryGetStringField(TEXT("replicationType"), ReplicationType);
+
+	UBlueprint* Blueprint = LoadObject<UBlueprint>(nullptr, *BlueprintPath);
+	if (!Blueprint)
+	{
+		Result->SetStringField(TEXT("error"), FString::Printf(TEXT("Blueprint not found: %s"), *BlueprintPath));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	// Find the variable in the blueprint
+	FName VarFName(*VariableName);
+	FBPVariableDescription* VarDesc = nullptr;
+	for (FBPVariableDescription& Var : Blueprint->NewVariables)
+	{
+		if (Var.VarName == VarFName)
+		{
+			VarDesc = &Var;
+			break;
+		}
+	}
+
+	if (!VarDesc)
+	{
+		Result->SetStringField(TEXT("error"), FString::Printf(TEXT("Variable '%s' not found in blueprint"), *VariableName));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	// Set the replication condition
+	if (ReplicationType == TEXT("Replicated"))
+	{
+		VarDesc->PropertyFlags |= CPF_Net;
+		VarDesc->PropertyFlags &= ~CPF_RepNotify;
+		VarDesc->ReplicationCondition = COND_None;
+		// Replication condition is already set on VarDesc above
+	}
+	else if (ReplicationType == TEXT("RepNotify"))
+	{
+		VarDesc->PropertyFlags |= CPF_Net;
+		VarDesc->PropertyFlags |= CPF_RepNotify;
+		VarDesc->ReplicationCondition = COND_None;
+		// Replication condition is already set on VarDesc above
+	}
+	else // "None"
+	{
+		VarDesc->PropertyFlags &= ~CPF_Net;
+		VarDesc->PropertyFlags &= ~CPF_RepNotify;
+	}
+
+	SaveBlueprint(Blueprint);
+
+	Result->SetStringField(TEXT("blueprintPath"), BlueprintPath);
+	Result->SetStringField(TEXT("variableName"), VariableName);
+	Result->SetStringField(TEXT("replicationType"), ReplicationType);
+	Result->SetBoolField(TEXT("success"), true);
+	return MakeShared<FJsonValueObject>(Result);
+}
+
+TSharedPtr<FJsonValue> FNetworkingHandlers::GetReplicationInfo(const TSharedPtr<FJsonObject>& Params)
+{
+	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+
+	FString BlueprintPath;
+	if (!Params->TryGetStringField(TEXT("blueprintPath"), BlueprintPath))
+	{
+		Result->SetStringField(TEXT("error"), TEXT("Missing 'blueprintPath' parameter"));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	UBlueprint* Blueprint = LoadObject<UBlueprint>(nullptr, *BlueprintPath);
+	if (!Blueprint || !Blueprint->GeneratedClass)
+	{
+		Result->SetStringField(TEXT("error"), FString::Printf(TEXT("Blueprint not found or has no generated class: %s"), *BlueprintPath));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	AActor* CDO = Cast<AActor>(Blueprint->GeneratedClass->GetDefaultObject());
+	if (!CDO)
+	{
+		Result->SetStringField(TEXT("error"), TEXT("CDO is not an Actor"));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	// General replication info
+	Result->SetStringField(TEXT("blueprintPath"), BlueprintPath);
+	Result->SetBoolField(TEXT("replicates"), CDO->GetIsReplicated());
+	Result->SetBoolField(TEXT("replicateMovement"), CDO->IsReplicatingMovement());
+	Result->SetBoolField(TEXT("alwaysRelevant"), CDO->bAlwaysRelevant);
+	Result->SetBoolField(TEXT("onlyRelevantToOwner"), CDO->bOnlyRelevantToOwner);
+	Result->SetNumberField(TEXT("netUpdateFrequency"), CDO->GetNetUpdateFrequency());
+	Result->SetNumberField(TEXT("netPriority"), CDO->NetPriority);
+	Result->SetNumberField(TEXT("netDormancy"), (int32)CDO->NetDormancy);
+
+	// Iterate all properties on the CDO class looking for replicated ones (CPF_Net flag)
+	TArray<TSharedPtr<FJsonValue>> ReplicatedProps;
+	for (TFieldIterator<FProperty> PropIt(Blueprint->GeneratedClass); PropIt; ++PropIt)
+	{
+		FProperty* Property = *PropIt;
+		if (!Property) continue;
+
+		if (Property->HasAnyPropertyFlags(CPF_Net))
+		{
+			TSharedPtr<FJsonObject> PropObj = MakeShared<FJsonObject>();
+			PropObj->SetStringField(TEXT("name"), Property->GetName());
+			PropObj->SetStringField(TEXT("type"), Property->GetCPPType());
+			PropObj->SetBoolField(TEXT("isRepNotify"), Property->HasAnyPropertyFlags(CPF_RepNotify));
+
+			// Determine replication condition from the blueprint variable description
+			FString ConditionStr = TEXT("COND_None");
+			for (const FBPVariableDescription& Var : Blueprint->NewVariables)
+			{
+				if (Var.VarName == Property->GetFName())
+				{
+					switch (Var.ReplicationCondition)
+					{
+					case COND_None:             ConditionStr = TEXT("COND_None"); break;
+					case COND_InitialOnly:      ConditionStr = TEXT("COND_InitialOnly"); break;
+					case COND_OwnerOnly:         ConditionStr = TEXT("COND_OwnerOnly"); break;
+					case COND_SkipOwner:         ConditionStr = TEXT("COND_SkipOwner"); break;
+					case COND_SimulatedOnly:     ConditionStr = TEXT("COND_SimulatedOnly"); break;
+					case COND_AutonomousOnly:    ConditionStr = TEXT("COND_AutonomousOnly"); break;
+					case COND_SimulatedOrPhysics: ConditionStr = TEXT("COND_SimulatedOrPhysics"); break;
+					case COND_InitialOrOwner:    ConditionStr = TEXT("COND_InitialOrOwner"); break;
+					case COND_Custom:            ConditionStr = TEXT("COND_Custom"); break;
+					case COND_ReplayOrOwner:     ConditionStr = TEXT("COND_ReplayOrOwner"); break;
+					case COND_ReplayOnly:        ConditionStr = TEXT("COND_ReplayOnly"); break;
+					case COND_SkipReplay:        ConditionStr = TEXT("COND_SkipReplay"); break;
+					case COND_Dynamic:           ConditionStr = TEXT("COND_Dynamic"); break;
+					case COND_Never:             ConditionStr = TEXT("COND_Never"); break;
+					default:                     ConditionStr = TEXT("Unknown"); break;
+					}
+					break;
+				}
+			}
+			PropObj->SetStringField(TEXT("replicationCondition"), ConditionStr);
+
+			// Rep notify function name
+			if (Property->HasAnyPropertyFlags(CPF_RepNotify) && Property->RepNotifyFunc != NAME_None)
+			{
+				PropObj->SetStringField(TEXT("repNotifyFunc"), Property->RepNotifyFunc.ToString());
+			}
+
+			ReplicatedProps.Add(MakeShared<FJsonValueObject>(PropObj));
+		}
+	}
+
+	Result->SetArrayField(TEXT("replicatedProperties"), ReplicatedProps);
+	Result->SetNumberField(TEXT("replicatedPropertyCount"), ReplicatedProps.Num());
+	Result->SetBoolField(TEXT("success"), true);
+	return MakeShared<FJsonValueObject>(Result);
+}
+
+TSharedPtr<FJsonValue> FNetworkingHandlers::SetOwnerOnlyRelevant(const TSharedPtr<FJsonObject>& Params)
+{
+	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+
+	FString BlueprintPath;
+	if (!Params->TryGetStringField(TEXT("blueprintPath"), BlueprintPath))
+	{
+		Result->SetStringField(TEXT("error"), TEXT("Missing 'blueprintPath' parameter"));
+		Result->SetBoolField(TEXT("success"), false);
+		return MakeShared<FJsonValueObject>(Result);
+	}
+
+	AActor* CDO = LoadBlueprintCDO(BlueprintPath, Result);
+	if (!CDO) return MakeShared<FJsonValueObject>(Result);
+
+	bool bOnlyRelevantToOwner = false;
+	Params->TryGetBoolField(TEXT("onlyRelevantToOwner"), bOnlyRelevantToOwner);
+	CDO->bOnlyRelevantToOwner = bOnlyRelevantToOwner;
+
+	UBlueprint* Blueprint = LoadObject<UBlueprint>(nullptr, *BlueprintPath);
+	SaveBlueprint(Blueprint);
+
+	Result->SetStringField(TEXT("blueprintPath"), BlueprintPath);
+	Result->SetBoolField(TEXT("onlyRelevantToOwner"), bOnlyRelevantToOwner);
+	Result->SetBoolField(TEXT("success"), true);
+	return MakeShared<FJsonValueObject>(Result);
+}
+
+TSharedPtr<FJsonValue> FNetworkingHandlers::SetNetLoadOnClient(const TSharedPtr<FJsonObject>& Params)
+{
+	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+	AActor* CDO = LoadBlueprintCDO(Params->GetStringField(TEXT("blueprintPath")), Result);
+	if (!CDO) return MakeShared<FJsonValueObject>(Result);
+
+	bool bLoadOnClient = true;
+	Params->TryGetBoolField(TEXT("loadOnClient"), bLoadOnClient);
+
+	FProperty* Prop = CDO->GetClass()->FindPropertyByName(TEXT("bNetLoadOnClient"));
+	if (Prop)
+	{
+		bool* ValPtr = Prop->ContainerPtrToValuePtr<bool>(CDO);
+		if (ValPtr)
+		{
+			*ValPtr = bLoadOnClient;
+		}
+	}
+
+	UBlueprint* BP = Cast<UBlueprint>(UEditorAssetLibrary::LoadAsset(Params->GetStringField(TEXT("blueprintPath"))));
+	if (BP) SaveBlueprint(BP);
+
+	Result->SetStringField(TEXT("blueprintPath"), Params->GetStringField(TEXT("blueprintPath")));
+	Result->SetBoolField(TEXT("loadOnClient"), bLoadOnClient);
+	Result->SetBoolField(TEXT("success"), true);
+	return MakeShared<FJsonValueObject>(Result);
+}
+
+TSharedPtr<FJsonValue> FNetworkingHandlers::ConfigureNetCullDistance(const TSharedPtr<FJsonObject>& Params)
+{
+	TSharedPtr<FJsonObject> Result = MakeShared<FJsonObject>();
+	AActor* CDO = LoadBlueprintCDO(Params->GetStringField(TEXT("blueprintPath")), Result);
+	if (!CDO) return MakeShared<FJsonValueObject>(Result);
+
+	double Distance = 225000000.0;
+	Params->TryGetNumberField(TEXT("netCullDistanceSquared"), Distance);
+
+	FProperty* Prop = CDO->GetClass()->FindPropertyByName(TEXT("NetCullDistanceSquared"));
+	if (Prop)
+	{
+		FFloatProperty* FloatProp = CastField<FFloatProperty>(Prop);
+		FDoubleProperty* DoubleProp = CastField<FDoubleProperty>(Prop);
+		if (FloatProp)
+		{
+			FloatProp->SetPropertyValue_InContainer(CDO, static_cast<float>(Distance));
+		}
+		else if (DoubleProp)
+		{
+			DoubleProp->SetPropertyValue_InContainer(CDO, Distance);
+		}
+	}
+
+	UBlueprint* BP = Cast<UBlueprint>(UEditorAssetLibrary::LoadAsset(Params->GetStringField(TEXT("blueprintPath"))));
+	if (BP) SaveBlueprint(BP);
+
+	Result->SetStringField(TEXT("blueprintPath"), Params->GetStringField(TEXT("blueprintPath")));
+	Result->SetNumberField(TEXT("netCullDistanceSquared"), Distance);
+	Result->SetBoolField(TEXT("success"), true);
+	return MakeShared<FJsonValueObject>(Result);
+}

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/NetworkingHandlers.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Dom/JsonValue.h"
+#include "Dom/JsonObject.h"
+
+class FNetworkingHandlers
+{
+public:
+	static void RegisterHandlers(class FMCPHandlerRegistry& Registry);
+
+private:
+	static TSharedPtr<FJsonValue> GetNetworkingInfo(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetReplicates(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> ConfigureNetUpdateFrequency(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetNetDormancy(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetAlwaysRelevant(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetNetPriority(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetReplicateMovement(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetVariableReplication(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> GetReplicationInfo(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetOwnerOnlyRelevant(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetNetLoadOnClient(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> ConfigureNetCullDistance(const TSharedPtr<FJsonObject>& Params);
+
+	// Helper to load blueprint CDO as AActor
+	static AActor* LoadBlueprintCDO(const FString& BlueprintPath, TSharedPtr<FJsonObject>& OutResult);
+	static void SaveBlueprint(UBlueprint* Blueprint);
+};