SERCAN
- 25 Tem
- 2 dakikada okunur

Using UDP in Unreal Engine

Unreal Engine provides a versatile framework for networking, including support for User Datagram Protocol (UDP) communications. UDP is a connectionless protocol that allows for fast, lightweight communication, making it ideal for scenarios where speed is crucial and occasional data loss is acceptable, such as real-time gaming or live data streaming.

This guide will walk you through the basics of setting up and using UDP in Unreal Engine.

Prerequisites

Basic understanding of Unreal Engine.
Familiarity with C++ programming.
Unreal Engine installed.

Step 1: Project Setup

Create or Open a Project:

Launch Unreal Engine and create a new C++ project or open an existing one.
Ensure your project is set up to use C++ by adding a new C++ class if necessary. 2.Include Necessary Modules:

Open your project's .uproject file.
Add the following modules to the "Modules" section if they are not already present:

"Modules": [

    "Name": "YourProjectName",

    "Type": "Runtime",

    "LoadingPhase": "Default"

},

    "Name": "Sockets",

    "Type": "Runtime",

    "LoadingPhase": "Default"

},

    "Name": "Networking",

    "Type": "Runtime",

    "LoadingPhase": "Default"

}
]

Step 2: Creating a UDP Socket

Include Headers:

In your C++ class, include the necessary headers:

#include "Networking.h"
#include "Sockets.h"
#include "SocketSubsystem.h"
#include "IPAddress.h"

2. Creating the UDP Socket:

Create a function to initialize the UDP socket:

bool InitializeUDPSocket(FSocket*& Socket, const FString& SocketName, const FString& IP, const int32 Port)

    Socket = FUdpSocketBuilder(*SocketName)

        .AsReusable()

        .AsNonBlocking()

        .WithBroadcast()

        .BoundToAddress(FIPv4Address::Any)

        .BoundToPort(Port)

        .WithReceiveBufferSize(2 * 1024 * 1024);

    if (!Socket)

        UE_LOG(LogTemp, Error, TEXT("Failed to create UDP socket"));

        return false;

    return true;

3.Initialize the Socket:

Call the InitializeUDPSocket function from your class constructor or a setup method:

FSocket* UDPSocket;

if (!InitializeUDPSocket(UDPSocket, TEXT("MyUDPSocket"), TEXT("127.0.0.1"), 8000))

    // Handle error
}

Step 3: Sending Data

Prepare Data:

Convert the data you want to send into a byte array:

TArray<uint8> Data;
FString Message = TEXT("Hello, Unreal UDP!");
Data.AddUninitialized(Message.Len());
StringToBytes(Message, Data.GetData(), Message.Len());

2. Send Data:

Use the SendTo method to send the data to the desired IP and port:

int32 BytesSent = 0;
TSharedRef<FInternetAddr> RemoteAddress = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();
bool bIsValid;
RemoteAddress->SetIp(TEXT("127.0.0.1"), bIsValid);
RemoteAddress->SetPort(8000);

if (UDPSocket->SendTo(Data.GetData(), Data.Num(), BytesSent, *RemoteAddress))
{
    UE_LOG(LogTemp, Log, TEXT("Sent %d bytes"), BytesSent);
}
else
{
    UE_LOG(LogTemp, Error, TEXT("Failed to send data"));
}

Step 4: Receiving Data

Receive Data:

Create a function to receive data:

void ReceiveData(FSocket* Socket)
{
    TArray<uint8> ReceivedData;
    uint32 Size;
    while (Socket->HasPendingData(Size))
    {
        ReceivedData.SetNumUninitialized(FMath::Min(Size, 65507u));

        int32 BytesRead = 0;
        Socket->Recv(ReceivedData.GetData(), ReceivedData.Num(), BytesRead);

        FString ReceivedString = BytesToString(ReceivedData.GetData(), BytesRead);
        UE_LOG(LogTemp, Log, TEXT("Received: %s"), *ReceivedString);
    }
}

2. Call Receive Function:

Call the ReceiveData function periodically, for example, in the Tick method:

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

    if (UDPSocket)
    {
        ReceiveData(UDPSocket);
    }
}

Step 5: Cleanup

Close the Socket:

Ensure to close and clean up the socket when it is no longer needed:

if (UDPSocket)

    UDPSocket->Close();

    ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->DestroySocket(UDPSocket);

    UDPSocket = nullptr;

Conclusion

By following these steps, you can set up UDP communication in Unreal Engine, enabling fast and efficient data transfer for your real-time applications. This basic setup can be expanded with error handling, advanced data serialization, and other networking features to meet your project's specific needs.

...