@nice2dev/game-engine 1.0.5 → 1.0.10

package/dist/esm/unreal-integration/UnrealLiveLink.js

@@ -0,0 +1,1182 @@
+/**
+ * @file UnrealLiveLink.ts
+ * @description Unreal Engine Live Link for Nice2Dev Game Engine
+ * PRO-1.10.2: Unreal Live Link
+ *
+ * Features:
+ * - WebSocket-based real-time sync with Unreal Editor
+ * - Actor selection mirroring
+ * - Property synchronization
+ * - PIE (Play In Editor) bridge
+ * - Live Coding integration
+ * - C++ Editor Plugin generation
+ */
+// ============================================================
+// Unreal Live Link Client
+// ============================================================
+class UnrealLiveLinkClient {
+    constructor(options) {
+        this.ws = null;
+        this.callbacks = {};
+        this.messageQueue = [];
+        this.pendingRequests = new Map();
+        this.pingTimer = null;
+        this.reconnectTimer = null;
+        this.subscriptions = new Set();
+        this.options = {
+            host: 'localhost',
+            port: 8890,
+            reconnect: true,
+            reconnectInterval: 2000,
+            maxReconnectAttempts: 10,
+            pingInterval: 5000,
+            timeout: 10000,
+            ...options,
+        };
+        this.state = {
+            connected: false,
+            connecting: false,
+            reconnecting: false,
+            reconnectAttempts: 0,
+            lastPing: 0,
+            latency: 0,
+            sessionId: null,
+            engineVersion: null,
+            projectName: null,
+        };
+    }
+    // ─── Connection ────────────────────────────────────────
+    connect() {
+        return new Promise((resolve, reject) => {
+            if (this.state.connected || this.state.connecting) {
+                reject(new Error('Already connected or connecting'));
+                return;
+            }
+            this.state.connecting = true;
+            const url = `ws://${this.options.host}:${this.options.port}`;
+            try {
+                this.ws = new WebSocket(url);
+                this.setupWebSocketHandlers(resolve, reject);
+            }
+            catch (error) {
+                this.state.connecting = false;
+                reject(error);
+            }
+        });
+    }
+    disconnect() {
+        this.stopPingTimer();
+        this.stopReconnectTimer();
+        if (this.ws) {
+            this.ws.close(1000, 'Client disconnect');
+            this.ws = null;
+        }
+        this.state.connected = false;
+        this.state.connecting = false;
+        this.state.reconnecting = false;
+        this.state.reconnectAttempts = 0;
+    }
+    setupWebSocketHandlers(resolve, reject) {
+        if (!this.ws) {
+            return;
+        }
+        const timeoutId = setTimeout(() => {
+            if (!this.state.connected) {
+                this.ws?.close();
+                reject(new Error('Connection timeout'));
+            }
+        }, this.options.timeout);
+        this.ws.onopen = () => {
+            clearTimeout(timeoutId);
+            this.state.connecting = false;
+            this.state.reconnecting = false;
+            this.state.reconnectAttempts = 0;
+            // Send handshake
+            this.sendMessage({
+                type: 'handshake',
+                timestamp: Date.now(),
+                payload: {
+                    version: '1.0.0',
+                    clientName: 'Nice2Dev Game Engine',
+                    capabilities: ['selection', 'transform', 'properties', 'pie', 'livecoding', 'debug'],
+                },
+            });
+        };
+        this.ws.onclose = (event) => {
+            clearTimeout(timeoutId);
+            this.stopPingTimer();
+            const wasConnected = this.state.connected;
+            this.state.connected = false;
+            this.state.connecting = false;
+            this.state.sessionId = null;
+            if (wasConnected) {
+                this.callbacks.onDisconnected?.(event.reason || 'Connection closed');
+            }
+            if (this.options.reconnect &&
+                this.state.reconnectAttempts < this.options.maxReconnectAttempts) {
+                this.scheduleReconnect();
+            }
+            if (!wasConnected) {
+                reject(new Error(event.reason || 'Connection failed'));
+            }
+        };
+        this.ws.onerror = (error) => {
+            this.callbacks.onError?.(new Error('WebSocket error'));
+            console.error('Unreal Live Link WebSocket error:', error);
+        };
+        this.ws.onmessage = (event) => {
+            try {
+                const message = JSON.parse(event.data);
+                this.handleMessage(message, resolve);
+            }
+            catch (error) {
+                console.error('Failed to parse message:', error);
+            }
+        };
+    }
+    handleMessage(message, onHandshakeComplete) {
+        switch (message.type) {
+            case 'handshake_ack':
+                this.handleHandshakeAck(message.payload, onHandshakeComplete);
+                break;
+            case 'pong':
+                this.handlePong();
+                break;
+            case 'actor_selected':
+                this.callbacks.onActorSelected?.(message.payload);
+                break;
+            case 'actor_deselected':
+                this.callbacks.onActorDeselected?.();
+                break;
+            case 'actor_transform_changed':
+                this.callbacks.onActorTransformChanged?.(message.payload);
+                break;
+            case 'actor_property_changed':
+                this.callbacks.onActorPropertyChanged?.(message.payload);
+                break;
+            case 'actor_created': {
+                const p = message.payload;
+                this.callbacks.onActorCreated?.(p.actorPath, p.actorClass);
+                break;
+            }
+            case 'actor_deleted': {
+                const p = message.payload;
+                this.callbacks.onActorDeleted?.(p.actorPath);
+                break;
+            }
+            case 'level_loaded': {
+                const p = message.payload;
+                this.callbacks.onLevelLoaded?.(p.levelPath);
+                break;
+            }
+            case 'level_unloaded': {
+                const p = message.payload;
+                this.callbacks.onLevelUnloaded?.(p.levelPath);
+                break;
+            }
+            case 'world_changed': {
+                const p = message.payload;
+                this.callbacks.onWorldChanged?.(p.worldPath);
+                break;
+            }
+            case 'pie_started':
+                this.callbacks.onPIEStarted?.(message.payload);
+                break;
+            case 'pie_stopped':
+                this.callbacks.onPIEStopped?.();
+                break;
+            case 'pie_paused':
+                this.callbacks.onPIEPaused?.();
+                break;
+            case 'pie_resumed':
+                this.callbacks.onPIEResumed?.();
+                break;
+            case 'live_coding_started':
+            case 'live_coding_completed':
+            case 'live_coding_failed':
+                this.callbacks.onLiveCodingUpdate?.(message.payload);
+                break;
+            case 'breakpoint_hit':
+                this.callbacks.onBreakpointHit?.(message.payload);
+                break;
+            case 'log_message':
+                this.callbacks.onLogMessage?.(message.payload);
+                break;
+            case 'blueprint_compiled': {
+                const p = message.payload;
+                this.callbacks.onBlueprintCompiled?.(p.blueprintPath);
+                break;
+            }
+            case 'asset_saved': {
+                const p = message.payload;
+                this.callbacks.onAssetSaved?.(p.assetPath);
+                break;
+            }
+            case 'asset_imported': {
+                const p = message.payload;
+                this.callbacks.onAssetImported?.(p.assetPath);
+                break;
+            }
+            case 'execute_command_result':
+                this.handleCommandResult(message);
+                break;
+            case 'error':
+                console.error('Unreal Live Link error:', message.payload);
+                break;
+        }
+    }
+    handleHandshakeAck(payload, onComplete) {
+        this.state.connected = true;
+        this.state.sessionId = payload.sessionId;
+        this.state.engineVersion = payload.engineVersion;
+        this.state.projectName = payload.projectName;
+        this.startPingTimer();
+        // Re-subscribe to previous subscriptions
+        this.subscriptions.forEach((topic) => {
+            this.sendMessage({
+                type: 'subscribe',
+                timestamp: Date.now(),
+                payload: { topic },
+            });
+        });
+        // Process queued messages
+        this.flushMessageQueue();
+        this.callbacks.onConnected?.(this.state);
+        onComplete?.();
+    }
+    handlePong() {
+        this.state.latency = Date.now() - this.state.lastPing;
+    }
+    handleCommandResult(message) {
+        if (message.id && this.pendingRequests.has(message.id)) {
+            const { resolve } = this.pendingRequests.get(message.id);
+            this.pendingRequests.delete(message.id);
+            resolve(message.payload);
+        }
+    }
+    // ─── Message Sending ───────────────────────────────────
+    sendMessage(message) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            this.messageQueue.push(message);
+            return;
+        }
+        this.ws.send(JSON.stringify(message));
+    }
+    flushMessageQueue() {
+        while (this.messageQueue.length > 0) {
+            const message = this.messageQueue.shift();
+            if (message) {
+                this.sendMessage(message);
+            }
+        }
+    }
+    // ─── Ping/Reconnect ────────────────────────────────────
+    startPingTimer() {
+        this.pingTimer = setInterval(() => {
+            if (this.state.connected) {
+                this.state.lastPing = Date.now();
+                this.sendMessage({
+                    type: 'ping',
+                    timestamp: this.state.lastPing,
+                });
+            }
+        }, this.options.pingInterval);
+    }
+    stopPingTimer() {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = null;
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer) {
+            return;
+        }
+        this.state.reconnecting = true;
+        this.state.reconnectAttempts++;
+        this.callbacks.onReconnecting?.(this.state.reconnectAttempts);
+        this.reconnectTimer = setTimeout(async () => {
+            this.reconnectTimer = null;
+            try {
+                await this.connect();
+            }
+            catch {
+                // Will schedule another reconnect in onclose handler
+            }
+        }, this.options.reconnectInterval);
+    }
+    stopReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    // ─── Subscriptions ─────────────────────────────────────
+    subscribe(topic) {
+        this.subscriptions.add(topic);
+        if (this.state.connected) {
+            this.sendMessage({
+                type: 'subscribe',
+                timestamp: Date.now(),
+                payload: { topic },
+            });
+        }
+    }
+    unsubscribe(topic) {
+        this.subscriptions.delete(topic);
+        if (this.state.connected) {
+            this.sendMessage({
+                type: 'unsubscribe',
+                timestamp: Date.now(),
+                payload: { topic },
+            });
+        }
+    }
+    // ─── Commands ──────────────────────────────────────────
+    selectActor(actorPath) {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'SelectActor',
+                args: { actorPath },
+            },
+        });
+    }
+    focusActor(actorPath) {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'FocusActor',
+                args: { actorPath },
+            },
+        });
+    }
+    setActorTransform(actorPath, transform) {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'SetActorTransform',
+                args: { actorPath, ...transform },
+            },
+        });
+    }
+    setActorProperty(actorPath, propertyName, value) {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'SetActorProperty',
+                args: { actorPath, propertyName, value },
+            },
+        });
+    }
+    spawnActor(className, transform) {
+        const messageId = `spawn_${Date.now()}`;
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(messageId, { resolve: resolve, reject });
+            this.sendMessage({
+                type: 'execute_command',
+                id: messageId,
+                timestamp: Date.now(),
+                payload: {
+                    command: 'SpawnActor',
+                    args: { className, ...transform },
+                },
+            });
+            setTimeout(() => {
+                if (this.pendingRequests.has(messageId)) {
+                    this.pendingRequests.delete(messageId);
+                    reject(new Error('Spawn actor timeout'));
+                }
+            }, this.options.timeout);
+        });
+    }
+    deleteActor(actorPath) {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'DeleteActor',
+                args: { actorPath },
+            },
+        });
+    }
+    duplicateActor(actorPath) {
+        const messageId = `duplicate_${Date.now()}`;
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(messageId, { resolve: resolve, reject });
+            this.sendMessage({
+                type: 'execute_command',
+                id: messageId,
+                timestamp: Date.now(),
+                payload: {
+                    command: 'DuplicateActor',
+                    args: { actorPath },
+                },
+            });
+            setTimeout(() => {
+                if (this.pendingRequests.has(messageId)) {
+                    this.pendingRequests.delete(messageId);
+                    reject(new Error('Duplicate actor timeout'));
+                }
+            }, this.options.timeout);
+        });
+    }
+    // ─── PIE Control ───────────────────────────────────────
+    startPIE() {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'PIE.Start',
+            },
+        });
+    }
+    stopPIE() {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'PIE.Stop',
+            },
+        });
+    }
+    pausePIE() {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'PIE.Pause',
+            },
+        });
+    }
+    resumePIE() {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'PIE.Resume',
+            },
+        });
+    }
+    ejectFromPIE() {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'PIE.Eject',
+            },
+        });
+    }
+    possessInPIE() {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'PIE.Possess',
+            },
+        });
+    }
+    // ─── Live Coding ───────────────────────────────────────
+    triggerLiveCoding() {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'LiveCoding.Compile',
+            },
+        });
+    }
+    // ─── Debug ─────────────────────────────────────────────
+    setBreakpoint(blueprintPath, nodeId) {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'Debug.SetBreakpoint',
+                args: { blueprintPath, nodeId },
+            },
+        });
+    }
+    removeBreakpoint(blueprintPath, nodeId) {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'Debug.RemoveBreakpoint',
+                args: { blueprintPath, nodeId },
+            },
+        });
+    }
+    continueExecution() {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'Debug.Continue',
+            },
+        });
+    }
+    stepOver() {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'Debug.StepOver',
+            },
+        });
+    }
+    stepInto() {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'Debug.StepInto',
+            },
+        });
+    }
+    stepOut() {
+        this.sendMessage({
+            type: 'execute_command',
+            timestamp: Date.now(),
+            payload: {
+                command: 'Debug.StepOut',
+            },
+        });
+    }
+    // ─── Console Commands ──────────────────────────────────
+    executeConsoleCommand(command) {
+        const messageId = `console_${Date.now()}`;
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(messageId, { resolve: resolve, reject });
+            this.sendMessage({
+                type: 'execute_command',
+                id: messageId,
+                timestamp: Date.now(),
+                payload: {
+                    command: 'Console.Execute',
+                    args: { command },
+                },
+            });
+            setTimeout(() => {
+                if (this.pendingRequests.has(messageId)) {
+                    this.pendingRequests.delete(messageId);
+                    reject(new Error('Console command timeout'));
+                }
+            }, this.options.timeout);
+        });
+    }
+    // ─── State ─────────────────────────────────────────────
+    getState() {
+        return { ...this.state };
+    }
+    isConnected() {
+        return this.state.connected;
+    }
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+}
+function generateUnrealEditorPlugin(options) {
+    const { pluginName, displayName, author, description, version, websocketPort } = options;
+    const files = {};
+    // .uplugin file
+    files[`${pluginName}.uplugin`] = JSON.stringify({
+        FileVersion: 3,
+        Version: 1,
+        VersionName: version,
+        FriendlyName: displayName,
+        Description: description,
+        Category: 'Nice2Dev',
+        CreatedBy: author,
+        CreatedByURL: '',
+        DocsURL: '',
+        MarketplaceURL: '',
+        SupportURL: '',
+        CanContainContent: false,
+        IsBetaVersion: true,
+        IsExperimentalVersion: false,
+        Installed: false,
+        Modules: [
+            {
+                Name: pluginName,
+                Type: 'Editor',
+                LoadingPhase: 'PostEngineInit',
+            },
+        ],
+    }, null, 2);
+    // Module header
+    files[`Source/${pluginName}/Public/${pluginName}Module.h`] =
+        `// Copyright Nice2Dev. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Modules/ModuleManager.h"
+
+class F${pluginName}Module : public IModuleInterface
+{
+public:
+    virtual void StartupModule() override;
+    virtual void ShutdownModule() override;
+
+private:
+    TSharedPtr<class FNice2DevLiveLinkServer> LiveLinkServer;
+};
+`;
+    // Module implementation
+    files[`Source/${pluginName}/Private/${pluginName}Module.cpp`] =
+        `// Copyright Nice2Dev. All Rights Reserved.
+
+#include "${pluginName}Module.h"
+#include "Nice2DevLiveLinkServer.h"
+#include "LevelEditor.h"
+#include "Editor.h"
+
+#define LOCTEXT_NAMESPACE "F${pluginName}Module"
+
+void F${pluginName}Module::StartupModule()
+{
+    // Start the WebSocket server
+    LiveLinkServer = MakeShared<FNice2DevLiveLinkServer>(${websocketPort});
+    LiveLinkServer->Start();
+
+    UE_LOG(LogTemp, Log, TEXT("Nice2Dev Live Link: Server started on port ${websocketPort}"));
+}
+
+void F${pluginName}Module::ShutdownModule()
+{
+    if (LiveLinkServer.IsValid())
+    {
+        LiveLinkServer->Stop();
+        LiveLinkServer.Reset();
+    }
+
+    UE_LOG(LogTemp, Log, TEXT("Nice2Dev Live Link: Server stopped"));
+}
+
+#undef LOCTEXT_NAMESPACE
+
+IMPLEMENT_MODULE(F${pluginName}Module, ${pluginName})
+`;
+    // WebSocket Server header
+    files[`Source/${pluginName}/Public/Nice2DevLiveLinkServer.h`] =
+        `// Copyright Nice2Dev. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "IWebSocketServer.h"
+#include "Tickable.h"
+
+DECLARE_LOG_CATEGORY_EXTERN(LogNice2DevLiveLink, Log, All);
+
+class FNice2DevLiveLinkServer : public FTickableGameObject
+{
+public:
+    FNice2DevLiveLinkServer(int32 Port);
+    virtual ~FNice2DevLiveLinkServer();
+
+    void Start();
+    void Stop();
+
+    // FTickableGameObject interface
+    virtual void Tick(float DeltaTime) override;
+    virtual bool IsTickable() const override { return bIsRunning; }
+    virtual TStatId GetStatId() const override;
+
+private:
+    void OnClientConnected(INetworkingWebSocket* ClientWebSocket);
+    void OnClientDisconnected(INetworkingWebSocket* ClientWebSocket);
+    void OnMessageReceived(void* Data, int32 Size, INetworkingWebSocket* ClientWebSocket);
+
+    void SendMessageToClient(INetworkingWebSocket* Client, const FString& Message);
+    void SendMessageToAllClients(const FString& Message);
+    void BroadcastActorSelection();
+    void BroadcastActorTransform(AActor* Actor);
+
+    void HandleCommand(const FString& Command, const TSharedPtr<FJsonObject>& Args, INetworkingWebSocket* Client, const FString& MessageId);
+
+    // Event handlers
+    void OnActorSelectionChanged(const TArray<UObject*>& NewSelection, bool bForceRefresh);
+    void OnActorMoving(AActor* Actor);
+    void OnMapChange(uint32 MapChangeFlags);
+    void OnBeginPIE(bool bIsSimulating);
+    void OnEndPIE(bool bIsSimulating);
+    void OnPausePIE(bool bIsSimulating);
+    void OnResumePIE(bool bIsSimulating);
+
+    TSharedPtr<IWebSocketServer> WebSocketServer;
+    TArray<INetworkingWebSocket*> ConnectedClients;
+    int32 ServerPort;
+    bool bIsRunning = false;
+    FString SessionId;
+
+    FDelegateHandle SelectionChangedHandle;
+    FDelegateHandle ActorMovingHandle;
+    FDelegateHandle MapChangeHandle;
+    FDelegateHandle BeginPIEHandle;
+    FDelegateHandle EndPIEHandle;
+    FDelegateHandle PausePIEHandle;
+    FDelegateHandle ResumePIEHandle;
+};
+`;
+    // WebSocket Server implementation
+    files[`Source/${pluginName}/Private/Nice2DevLiveLinkServer.cpp`] =
+        `// Copyright Nice2Dev. All Rights Reserved.
+
+#include "Nice2DevLiveLinkServer.h"
+#include "WebSocketsModule.h"
+#include "IWebSocketServer.h"
+#include "Dom/JsonObject.h"
+#include "Serialization/JsonReader.h"
+#include "Serialization/JsonWriter.h"
+#include "Serialization/JsonSerializer.h"
+#include "Editor.h"
+#include "LevelEditor.h"
+#include "Selection.h"
+#include "Engine/World.h"
+#include "GameFramework/Actor.h"
+#include "Kismet/GameplayStatics.h"
+
+DEFINE_LOG_CATEGORY(LogNice2DevLiveLink);
+
+FNice2DevLiveLinkServer::FNice2DevLiveLinkServer(int32 Port)
+    : ServerPort(Port)
+{
+    SessionId = FGuid::NewGuid().ToString();
+}
+
+FNice2DevLiveLinkServer::~FNice2DevLiveLinkServer()
+{
+    Stop();
+}
+
+void FNice2DevLiveLinkServer::Start()
+{
+    if (bIsRunning) return;
+
+    WebSocketServer = FModuleManager::Get().LoadModuleChecked<FWebSocketsModule>("WebSockets")
+        .CreateServer(ServerPort, TEXT("ws"));
+
+    if (!WebSocketServer.IsValid())
+    {
+        UE_LOG(LogNice2DevLiveLink, Error, TEXT("Failed to create WebSocket server"));
+        return;
+    }
+
+    WebSocketServer->OnClientConnected().AddRaw(this, &FNice2DevLiveLinkServer::OnClientConnected);
+    WebSocketServer->OnClientDisconnected().AddRaw(this, &FNice2DevLiveLinkServer::OnClientDisconnected);
+
+    // Bind editor events
+    SelectionChangedHandle = USelection::SelectionChangedEvent.AddRaw(this, &FNice2DevLiveLinkServer::OnActorSelectionChanged);
+    ActorMovingHandle = GEditor->OnActorMoving().AddRaw(this, &FNice2DevLiveLinkServer::OnActorMoving);
+    MapChangeHandle = FEditorDelegates::MapChange.AddRaw(this, &FNice2DevLiveLinkServer::OnMapChange);
+    BeginPIEHandle = FEditorDelegates::BeginPIE.AddRaw(this, &FNice2DevLiveLinkServer::OnBeginPIE);
+    EndPIEHandle = FEditorDelegates::EndPIE.AddRaw(this, &FNice2DevLiveLinkServer::OnEndPIE);
+    PausePIEHandle = FEditorDelegates::PausePIE.AddRaw(this, &FNice2DevLiveLinkServer::OnPausePIE);
+    ResumePIEHandle = FEditorDelegates::ResumePIE.AddRaw(this, &FNice2DevLiveLinkServer::OnResumePIE);
+
+    bIsRunning = true;
+    UE_LOG(LogNice2DevLiveLink, Log, TEXT("WebSocket server started on port %d"), ServerPort);
+}
+
+void FNice2DevLiveLinkServer::Stop()
+{
+    if (!bIsRunning) return;
+
+    // Unbind events
+    USelection::SelectionChangedEvent.Remove(SelectionChangedHandle);
+    GEditor->OnActorMoving().Remove(ActorMovingHandle);
+    FEditorDelegates::MapChange.Remove(MapChangeHandle);
+    FEditorDelegates::BeginPIE.Remove(BeginPIEHandle);
+    FEditorDelegates::EndPIE.Remove(EndPIEHandle);
+    FEditorDelegates::PausePIE.Remove(PausePIEHandle);
+    FEditorDelegates::ResumePIE.Remove(ResumePIEHandle);
+
+    ConnectedClients.Empty();
+    WebSocketServer.Reset();
+    bIsRunning = false;
+}
+
+void FNice2DevLiveLinkServer::Tick(float DeltaTime)
+{
+    if (WebSocketServer.IsValid())
+    {
+        WebSocketServer->Tick();
+    }
+}
+
+TStatId FNice2DevLiveLinkServer::GetStatId() const
+{
+    RETURN_QUICK_DECLARE_CYCLE_STAT(FNice2DevLiveLinkServer, STATGROUP_Tickables);
+}
+
+void FNice2DevLiveLinkServer::OnClientConnected(INetworkingWebSocket* ClientWebSocket)
+{
+    ConnectedClients.Add(ClientWebSocket);
+    ClientWebSocket->OnMessage().AddRaw(this, &FNice2DevLiveLinkServer::OnMessageReceived);
+    
+    UE_LOG(LogNice2DevLiveLink, Log, TEXT("Client connected. Total clients: %d"), ConnectedClients.Num());
+}
+
+void FNice2DevLiveLinkServer::OnClientDisconnected(INetworkingWebSocket* ClientWebSocket)
+{
+    ConnectedClients.Remove(ClientWebSocket);
+    UE_LOG(LogNice2DevLiveLink, Log, TEXT("Client disconnected. Total clients: %d"), ConnectedClients.Num());
+}
+
+void FNice2DevLiveLinkServer::OnMessageReceived(void* Data, int32 Size, INetworkingWebSocket* ClientWebSocket)
+{
+    FString MessageString(Size, static_cast<UTF8CHAR*>(Data));
+    
+    TSharedPtr<FJsonObject> JsonObject;
+    TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(MessageString);
+    
+    if (!FJsonSerializer::Deserialize(Reader, JsonObject) || !JsonObject.IsValid())
+    {
+        UE_LOG(LogNice2DevLiveLink, Warning, TEXT("Failed to parse message: %s"), *MessageString);
+        return;
+    }
+
+    FString MessageType;
+    if (!JsonObject->TryGetStringField(TEXT("type"), MessageType))
+    {
+        return;
+    }
+
+    FString MessageId = JsonObject->GetStringField(TEXT("id"));
+
+    if (MessageType == TEXT("handshake"))
+    {
+        // Send handshake acknowledgment
+        TSharedPtr<FJsonObject> Response = MakeShared<FJsonObject>();
+        Response->SetStringField(TEXT("type"), TEXT("handshake_ack"));
+        Response->SetNumberField(TEXT("timestamp"), FDateTime::UtcNow().ToUnixTimestamp() * 1000);
+        
+        TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
+        Payload->SetStringField(TEXT("version"), TEXT("1.0.0"));
+        Payload->SetStringField(TEXT("engineVersion"), ENGINE_VERSION_STRING);
+        Payload->SetStringField(TEXT("projectName"), FApp::GetProjectName());
+        Payload->SetStringField(TEXT("sessionId"), SessionId);
+        
+        TArray<TSharedPtr<FJsonValue>> Capabilities;
+        Capabilities.Add(MakeShared<FJsonValueString>(TEXT("selection")));
+        Capabilities.Add(MakeShared<FJsonValueString>(TEXT("transform")));
+        Capabilities.Add(MakeShared<FJsonValueString>(TEXT("properties")));
+        Capabilities.Add(MakeShared<FJsonValueString>(TEXT("pie")));
+        Capabilities.Add(MakeShared<FJsonValueString>(TEXT("livecoding")));
+        Capabilities.Add(MakeShared<FJsonValueString>(TEXT("debug")));
+        Payload->SetArrayField(TEXT("capabilities"), Capabilities);
+        
+        Response->SetObjectField(TEXT("payload"), Payload);
+        
+        FString ResponseString;
+        TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&ResponseString);
+        FJsonSerializer::Serialize(Response.ToSharedRef(), Writer);
+        
+        SendMessageToClient(ClientWebSocket, ResponseString);
+    }
+    else if (MessageType == TEXT("ping"))
+    {
+        TSharedPtr<FJsonObject> Response = MakeShared<FJsonObject>();
+        Response->SetStringField(TEXT("type"), TEXT("pong"));
+        Response->SetNumberField(TEXT("timestamp"), FDateTime::UtcNow().ToUnixTimestamp() * 1000);
+        
+        FString ResponseString;
+        TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&ResponseString);
+        FJsonSerializer::Serialize(Response.ToSharedRef(), Writer);
+        
+        SendMessageToClient(ClientWebSocket, ResponseString);
+    }
+    else if (MessageType == TEXT("execute_command"))
+    {
+        const TSharedPtr<FJsonObject>* PayloadObject;
+        if (JsonObject->TryGetObjectField(TEXT("payload"), PayloadObject))
+        {
+            FString Command = (*PayloadObject)->GetStringField(TEXT("command"));
+            const TSharedPtr<FJsonObject>* Args;
+            TSharedPtr<FJsonObject> ArgsObj;
+            if ((*PayloadObject)->TryGetObjectField(TEXT("args"), Args))
+            {
+                ArgsObj = *Args;
+            }
+            HandleCommand(Command, ArgsObj, ClientWebSocket, MessageId);
+        }
+    }
+}
+
+void FNice2DevLiveLinkServer::SendMessageToClient(INetworkingWebSocket* Client, const FString& Message)
+{
+    if (Client)
+    {
+        TArray<uint8> Data;
+        FTCHARToUTF8 Converter(*Message);
+        Data.Append((uint8*)Converter.Get(), Converter.Length());
+        Client->Send(Data.GetData(), Data.Num(), false);
+    }
+}
+
+void FNice2DevLiveLinkServer::SendMessageToAllClients(const FString& Message)
+{
+    for (INetworkingWebSocket* Client : ConnectedClients)
+    {
+        SendMessageToClient(Client, Message);
+    }
+}
+
+void FNice2DevLiveLinkServer::HandleCommand(const FString& Command, const TSharedPtr<FJsonObject>& Args, INetworkingWebSocket* Client, const FString& MessageId)
+{
+    if (Command == TEXT("SelectActor"))
+    {
+        FString ActorPath = Args->GetStringField(TEXT("actorPath"));
+        // Implementation: Find and select actor
+    }
+    else if (Command == TEXT("SetActorTransform"))
+    {
+        FString ActorPath = Args->GetStringField(TEXT("actorPath"));
+        // Implementation: Set actor transform
+    }
+    else if (Command == TEXT("PIE.Start"))
+    {
+        GEditor->PlayInEditor(GWorld, true);
+    }
+    else if (Command == TEXT("PIE.Stop"))
+    {
+        GEditor->RequestEndPlayMap();
+    }
+    else if (Command == TEXT("PIE.Pause"))
+    {
+        GEditor->PlayWorld->bDebugPauseExecution = true;
+    }
+    else if (Command == TEXT("PIE.Resume"))
+    {
+        GEditor->PlayWorld->bDebugPauseExecution = false;
+    }
+    else if (Command == TEXT("LiveCoding.Compile"))
+    {
+        // Trigger Live Coding compile
+        ILiveCodingModule& LiveCodingModule = FModuleManager::LoadModuleChecked<ILiveCodingModule>("LiveCoding");
+        LiveCodingModule.EnableByDefault(true);
+        LiveCodingModule.Compile();
+    }
+}
+
+void FNice2DevLiveLinkServer::OnActorSelectionChanged(const TArray<UObject*>& NewSelection, bool bForceRefresh)
+{
+    TSharedPtr<FJsonObject> Message = MakeShared<FJsonObject>();
+    
+    if (NewSelection.Num() > 0 && NewSelection[0]->IsA<AActor>())
+    {
+        AActor* SelectedActor = Cast<AActor>(NewSelection[0]);
+        
+        Message->SetStringField(TEXT("type"), TEXT("actor_selected"));
+        Message->SetNumberField(TEXT("timestamp"), FDateTime::UtcNow().ToUnixTimestamp() * 1000);
+        
+        TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
+        Payload->SetStringField(TEXT("actorPath"), SelectedActor->GetPathName());
+        Payload->SetStringField(TEXT("actorClass"), SelectedActor->GetClass()->GetName());
+        Payload->SetStringField(TEXT("actorName"), SelectedActor->GetActorLabel());
+        Payload->SetBoolField(TEXT("isMultiSelect"), NewSelection.Num() > 1);
+        
+        if (NewSelection.Num() > 1)
+        {
+            TArray<TSharedPtr<FJsonValue>> SelectedPaths;
+            for (UObject* Obj : NewSelection)
+            {
+                if (AActor* Actor = Cast<AActor>(Obj))
+                {
+                    SelectedPaths.Add(MakeShared<FJsonValueString>(Actor->GetPathName()));
+                }
+            }
+            Payload->SetArrayField(TEXT("selectedPaths"), SelectedPaths);
+        }
+        
+        Message->SetObjectField(TEXT("payload"), Payload);
+    }
+    else
+    {
+        Message->SetStringField(TEXT("type"), TEXT("actor_deselected"));
+        Message->SetNumberField(TEXT("timestamp"), FDateTime::UtcNow().ToUnixTimestamp() * 1000);
+    }
+    
+    FString MessageString;
+    TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&MessageString);
+    FJsonSerializer::Serialize(Message.ToSharedRef(), Writer);
+    
+    SendMessageToAllClients(MessageString);
+}
+
+void FNice2DevLiveLinkServer::OnActorMoving(AActor* Actor)
+{
+    if (!Actor) return;
+    
+    TSharedPtr<FJsonObject> Message = MakeShared<FJsonObject>();
+    Message->SetStringField(TEXT("type"), TEXT("actor_transform_changed"));
+    Message->SetNumberField(TEXT("timestamp"), FDateTime::UtcNow().ToUnixTimestamp() * 1000);
+    
+    FVector Location = Actor->GetActorLocation();
+    FRotator Rotation = Actor->GetActorRotation();
+    FVector Scale = Actor->GetActorScale3D();
+    
+    TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
+    Payload->SetStringField(TEXT("actorPath"), Actor->GetPathName());
+    
+    TSharedPtr<FJsonObject> LocationObj = MakeShared<FJsonObject>();
+    LocationObj->SetNumberField(TEXT("x"), Location.X);
+    LocationObj->SetNumberField(TEXT("y"), Location.Y);
+    LocationObj->SetNumberField(TEXT("z"), Location.Z);
+    Payload->SetObjectField(TEXT("location"), LocationObj);
+    
+    TSharedPtr<FJsonObject> RotationObj = MakeShared<FJsonObject>();
+    RotationObj->SetNumberField(TEXT("pitch"), Rotation.Pitch);
+    RotationObj->SetNumberField(TEXT("yaw"), Rotation.Yaw);
+    RotationObj->SetNumberField(TEXT("roll"), Rotation.Roll);
+    Payload->SetObjectField(TEXT("rotation"), RotationObj);
+    
+    TSharedPtr<FJsonObject> ScaleObj = MakeShared<FJsonObject>();
+    ScaleObj->SetNumberField(TEXT("x"), Scale.X);
+    ScaleObj->SetNumberField(TEXT("y"), Scale.Y);
+    ScaleObj->SetNumberField(TEXT("z"), Scale.Z);
+    Payload->SetObjectField(TEXT("scale"), ScaleObj);
+    
+    Payload->SetBoolField(TEXT("isRelative"), false);
+    
+    Message->SetObjectField(TEXT("payload"), Payload);
+    
+    FString MessageString;
+    TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&MessageString);
+    FJsonSerializer::Serialize(Message.ToSharedRef(), Writer);
+    
+    SendMessageToAllClients(MessageString);
+}
+
+void FNice2DevLiveLinkServer::OnMapChange(uint32 MapChangeFlags)
+{
+    TSharedPtr<FJsonObject> Message = MakeShared<FJsonObject>();
+    Message->SetStringField(TEXT("type"), TEXT("world_changed"));
+    Message->SetNumberField(TEXT("timestamp"), FDateTime::UtcNow().ToUnixTimestamp() * 1000);
+    
+    TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
+    if (GWorld)
+    {
+        Payload->SetStringField(TEXT("worldPath"), GWorld->GetPathName());
+    }
+    Message->SetObjectField(TEXT("payload"), Payload);
+    
+    FString MessageString;
+    TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&MessageString);
+    FJsonSerializer::Serialize(Message.ToSharedRef(), Writer);
+    
+    SendMessageToAllClients(MessageString);
+}
+
+void FNice2DevLiveLinkServer::OnBeginPIE(bool bIsSimulating)
+{
+    TSharedPtr<FJsonObject> Message = MakeShared<FJsonObject>();
+    Message->SetStringField(TEXT("type"), TEXT("pie_started"));
+    Message->SetNumberField(TEXT("timestamp"), FDateTime::UtcNow().ToUnixTimestamp() * 1000);
+    
+    TSharedPtr<FJsonObject> Payload = MakeShared<FJsonObject>();
+    Payload->SetBoolField(TEXT("isPlaying"), true);
+    Payload->SetBoolField(TEXT("isPaused"), false);
+    Payload->SetBoolField(TEXT("isSimulating"), bIsSimulating);
+    Message->SetObjectField(TEXT("payload"), Payload);
+    
+    FString MessageString;
+    TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&MessageString);
+    FJsonSerializer::Serialize(Message.ToSharedRef(), Writer);
+    
+    SendMessageToAllClients(MessageString);
+}
+
+void FNice2DevLiveLinkServer::OnEndPIE(bool bIsSimulating)
+{
+    TSharedPtr<FJsonObject> Message = MakeShared<FJsonObject>();
+    Message->SetStringField(TEXT("type"), TEXT("pie_stopped"));
+    Message->SetNumberField(TEXT("timestamp"), FDateTime::UtcNow().ToUnixTimestamp() * 1000);
+    
+    FString MessageString;
+    TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&MessageString);
+    FJsonSerializer::Serialize(Message.ToSharedRef(), Writer);
+    
+    SendMessageToAllClients(MessageString);
+}
+
+void FNice2DevLiveLinkServer::OnPausePIE(bool bIsSimulating)
+{
+    TSharedPtr<FJsonObject> Message = MakeShared<FJsonObject>();
+    Message->SetStringField(TEXT("type"), TEXT("pie_paused"));
+    Message->SetNumberField(TEXT("timestamp"), FDateTime::UtcNow().ToUnixTimestamp() * 1000);
+    
+    FString MessageString;
+    TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&MessageString);
+    FJsonSerializer::Serialize(Message.ToSharedRef(), Writer);
+    
+    SendMessageToAllClients(MessageString);
+}
+
+void FNice2DevLiveLinkServer::OnResumePIE(bool bIsSimulating)
+{
+    TSharedPtr<FJsonObject> Message = MakeShared<FJsonObject>();
+    Message->SetStringField(TEXT("type"), TEXT("pie_resumed"));
+    Message->SetNumberField(TEXT("timestamp"), FDateTime::UtcNow().ToUnixTimestamp() * 1000);
+    
+    FString MessageString;
+    TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&MessageString);
+    FJsonSerializer::Serialize(Message.ToSharedRef(), Writer);
+    
+    SendMessageToAllClients(MessageString);
+}
+`;
+    // Build.cs
+    files[`Source/${pluginName}/${pluginName}.Build.cs`] =
+        `// Copyright Nice2Dev. All Rights Reserved.
+
+using UnrealBuildTool;
+
+public class ${pluginName} : ModuleRules
+{
+    public ${pluginName}(ReadOnlyTargetRules Target) : base(Target)
+    {
+        PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+
+        PublicDependencyModuleNames.AddRange(
+            new string[]
+            {
+                "Core",
+                "CoreUObject",
+                "Engine",
+                "InputCore",
+            }
+        );
+
+        PrivateDependencyModuleNames.AddRange(
+            new string[]
+            {
+                "UnrealEd",
+                "LevelEditor",
+                "WebSockets",
+                "Networking",
+                "Json",
+                "JsonUtilities",
+                "LiveCoding",
+            }
+        );
+    }
+}
+`;
+    return files;
+}
+// ============================================================
+// Factory Functions
+// ============================================================
+function createUnrealLiveLinkClient(options) {
+    return new UnrealLiveLinkClient(options);
+}
+
+export { UnrealLiveLinkClient, createUnrealLiveLinkClient, generateUnrealEditorPlugin };
+//# sourceMappingURL=UnrealLiveLink.js.map