نحوه اجرای ارتباطات سوکت در موتور غیر واقعی و Node.js

npm init -y
npm install ws

const WebSocket = require('ws');

const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', ws => {
  console.log('New connection established');

  ws.on('message', message => {
    console.log(`Received message: ${message}`);
    // Send back a response to the client
    ws.send('Message received by Node.js server!');
  });

  ws.on('close', () => {
    console.log('Connection closed');
  });
});

// Handle server errors
wss.on('error', err => {
  console.error('WebSocket Server Error:', err);
});

console.log('WebSocket server running on ws://localhost:8080');

node server.js

PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "WebSockets" });

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "WebSocketsModule.h"
#include "IWebSocket.h"
#include "WebSocketClientActor.generated.h"

UCLASS()
class YOURPROJECT_API AWebSocketClientActor : public AActor
{
    GENERATED_BODY()

public:
    AWebSocketClientActor();

protected:
    virtual void BeginPlay() override;
    virtual void Tick(float DeltaTime) override;

private:
    TSharedPtr WebSocket;

    void SetupWebSocket();
    void OnWebSocketMessageReceived(const FString& Message);
};

#include "WebSocketClientActor.h"
#include "Engine/Engine.h"

AWebSocketClientActor::AWebSocketClientActor()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AWebSocketClientActor::BeginPlay()
{
    Super::BeginPlay();
    SetupWebSocket();
}

void AWebSocketClientActor::SetupWebSocket()
{
    if (!FModuleManager::Get().IsModuleLoaded("WebSockets"))
    {
        FModuleManager::Get().LoadModule("WebSockets");
    }

    WebSocket = FWebSocketsModule::Get().CreateWebSocket(TEXT("ws://localhost:8080"));

    WebSocket->OnConnected().AddLambda([]()
    {
        UE_LOG(LogTemp, Log, TEXT("Successfully connected to WebSocket server"));
    });

    WebSocket->OnConnectionError().AddLambda([](const FString& Error)
    {
        UE_LOG(LogTemp, Error, TEXT("WebSocket Connection Failed: %s"), *Error);
    });

    WebSocket->OnClosed().AddLambda([](int32 StatusCode, const FString& Reason, bool bWasClean)
    {
        UE_LOG(LogTemp, Log, TEXT("WebSocket Closed: %s"), *Reason);
    });

    WebSocket->OnMessage().AddLambda([this](const FString& Message)
    {
        UE_LOG(LogTemp, Log, TEXT("Received WebSocket Message: %s"), *Message);
        OnWebSocketMessageReceived(Message);
    });

    WebSocket->Connect();
}

void AWebSocketClientActor::OnWebSocketMessageReceived(const FString& Message)
{
    if (Message.Contains("color"))
    {
        // Change the color of the actor based on the message
        UStaticMeshComponent* MeshComp = FindComponentByClass();
        if (MeshComp)
        {
            FLinearColor Color = FLinearColor::Red;
            UMaterialInstanceDynamic* DynMaterial = MeshComp->CreateAndSetMaterialInstanceDynamic(0);
            if (DynMaterial)
            {
                DynMaterial->SetVectorParameterValue(TEXT("BaseColor"), Color);
            }
        }
    }
}

void AWebSocketClientActor::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

    if (WebSocket && WebSocket->IsConnected())
    {
        WebSocket->Send(TEXT("Hello from Unreal Engine!"));
    }
}

using System.Collections;
using UnityEngine;
using WebSocketSharp;

public class WebSocketClient : MonoBehaviour
{
    private WebSocket ws;

    void Start()
    {
        ws = new WebSocket("ws://localhost:8080");

        ws.OnOpen += (sender, e) => {
            Debug.Log("WebSocket connected.");
        };

        ws.OnMessage += (sender, e) => {
            Debug.Log("Received: " + e.Data);
            // Handle the message
            HandleMessage(e.Data);
        };

        ws.Connect();
    }

    void HandleMessage(string message)
    {
        if (message.Contains("color"))
        {
            GetComponent().material.color = Color.red; // Example for Unity
        }
    }

    void Update()
    {
        if (ws != null && ws.IsAlive)
        {
            ws.Send("Hello from Unity!");
        }
    }

    void OnApplicationQuit()
    {
        if (ws != null)
        {
            ws.Close();
        }
    }
}