UE进阶实例38（UE Socket网络编程）

已于 2024-12-09 23:29:40 修改
阅读量6k 收藏 16
点赞数 2
分类专栏： Unreal 文章标签： Unreal
于 2022-02-01 13:32:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/unity3d_xyz/article/details/122763674
版权
本文档介绍了如何使用UE Socket进行网络编程，特别适用于小型和创业型公司的网络服务器，适用于VR和游戏场景。提供了纯绿色、高效能的代码，并针对客户端断开连接时服务器无法检测的问题提出解决方案，建议使用自定义Ping判定。此外，还分享了UPD Server和Client的参考资源及演示视频和源码链接。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

如果有遇到断开客户端，服务器无法检测的问题
Socket->GetConnectionState()判定有问题，可以使用自己的Ping来判定
https://forums.unrealengine.com/t/fsocket-getconnectionstate-always-returns-true/345349/3

UPD Server&Client参考
https://github.com/is-centre/udp-ue4-plugin-win64

#. 使用自定义参数加入Server

void AJoinPlayerController::JoinWithParams(int p1, FString& p2)
{
	const FString URLWithParams = FString::Printf(TEXT("127.0.0.1:7777?Param1=%d?Param2=%s"), p1, *p2);
	ClientTravel(URLWithParams, ETravelType::TRAVEL_Absolute);
}

FString AJoinServerParamsGameModeBase::InitNewPlayer(APlayerController* NewPlayerController, 
													 const FUniqueNetIdRepl& UniqueId, 
													 const FString& Options, 
													 const FString& Portal)
{
	GLog->Logf(TEXT("-------------Options:%s"), *Options);
	TArray<FString> Params;
	Options.ParseIntoArray(Params, TEXT("?"), true);

	int Count = 0;
	for (FString Param : Params)
	{
		FString Key, Value;
		Param.Split(TEXT("="), &Key, &Value);
		GLog->Logf(TEXT("-------------Param%d>>>[%s]:[%s]"), Count, *Key, *Value);
		Count++;
	}
	
	return Super::InitNewPlayer(NewPlayerController, UniqueId, Options, Portal);
}

#. UE4.27+新加入FUdpSocketReceiver

	int32 BytesSent = 0;

	FArrayWriter Writer;
	Writer << data;
	SenderSocket->SendTo(Writer.GetData(), Writer.Num(), BytesSent, *RemoteAddr);

	if (BytesSent <= 0)
	{
		UE_LOG(LogTemp, Error, TEXT("Socket exists, but receiver did not accept any packets."));
		return false;
	}

	Receiver = new FUdpSocketReceiver(ListenSocket, ThreadWaitTime, TEXT("UDP Receiver"));
	Receiver->OnDataReceived().BindUObject(this, &AUDPReceiver::Recv);
	Receiver->Start();
	
	FUDPData data;
	*ArrayReaderPtr << data;

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Networking.h"
#include "IPAddress.h"
#include "TCPServer.generated.h"

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FTCPEventSignature, int, Port);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FTCPMessageSignature, const TArray<uint8>&, Bytes);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FTCPClientSignture, const FString&, Client);

struct FTCPClient
{
	FSocket* Socket;
	FString Address;

	bool operator == (const FTCPClient& Other)
	{
		return Address == Other.Address;
	}
};

UCLASS(Blueprintable)
class UESOCKET_API ATCPServer : public AActor
{
	GENERATED_BODY()
	
public:	
	// Sets default values for this actor's properties
	ATCPServer();

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;
	virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

public:	
	// Called every frame
	virtual void Tick(float DeltaTime) override;

	FTCPMessageSignature OnReceivedBytes;
	UPROPERTY(BlueprintAssignable, BlueprintReadWrite)
	FTCPEventSignature OnListenBegin;
	FTCPEventSignature OnListenEnd;

	FTCPClientSignture OnClientConnected;
	FTCPClientSignture OnClientDisconnected;

	int32 ListenPort;
	FString ListenSocketName;
	int32 BufferMaxSize;

	bool bShouldAutoListen;
	bool bReceiveDataOnGameThread;
	bool bDisconnectOnFailedEmit;
	bool bShouldPing;
	float PingInterval;
	FString PingMessage;
	bool bIsConnected;
	
	void StartListenServer(const FString Ipv4, const int32 InListenPort = 3001);
	void StopListenServer();
	UFUNCTION(BlueprintCallable)
	bool Emit(const TArray<uint8>& Bytes, const FString& ToClient = TEXT("All"));
	void DisconnectClient(FString ClientAddress = TEXT("All"), bool bDisconnectNextTick = false);

private:
	TMap<FString, TSharedPtr<FTCPClient>> Clients;
	FSocket* ListenSocket;
	FThreadSafeBool bShouldListen;
	TFuture<void> ServerFinishedFuture;
	TArray<uint8> PingData;

	FString SocketDescription;
	TSharedPtr<FInternetAddr> RemoteAddress;
	
};


// Fill out your copyright notice in the Description page of Project Settings.


#include "TCPServer.h"

#include "UESocket.h"

// Sets default values
ATCPServer::ATCPServer()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	bShouldAutoListen = false;
	bReceiveDataOnGameThread = true;
	ListenPort = 3001;
	ListenSocketName = TEXT("ue4-tcp-server");
	bDisconnectOnFailedEmit = true;
	bShouldPing = false;
	PingInterval = 10.0f;
	PingMessage = TEXT("<Ping>");

	BufferMaxSize = 2 * 1024 * 1024;
}

// Called when the game starts or when spawned
void ATCPServer::BeginPlay()
{
	Super::BeginPlay();
	PingData.Append((uint8*)TCHAR_TO_UTF8(*PingMessage), PingMessage.Len());

	if (bShouldAutoListen)
	{
		StartListenServer(TEXT("0.0.0.0"), ListenPort);
	}
}

void ATCPServer::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
	Super::EndPlay(EndPlayReason);
	StopListenServer();
	
}

// Called every frame
void ATCPServer::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

}

void ATCPServer::StartListenServer(const FString Ipv4, const int32 InListenPort)
{
	FIPv4Address Address;
	FIPv4Address::Parse(TEXT("0.0.0.0"), Address);

	FIPv4Endpoint Endpoint(Address, InListenPort);
	ListenSocket = FTcpSocketBuilder(*ListenSocketName)
			.AsReusable()
			.BoundToEndpoint(Endpoint)
			.WithReceiveBufferSize(BufferMaxSize);

	ListenSocket->SetReceiveBufferSize(BufferMaxSize, BufferMaxSize);
	ListenSocket->SetSendBufferSize(BufferMaxSize, BufferMaxSize);

	ListenSocket->Listen(8);

	OnListenBegin.Broadcast(InListenPort);
	bShouldListen = true;

	ServerFinishedFuture = ThreadUtility::RunLambdaOnBackgroundThread([&]()
	{
		uint32 BufferSize = 0;
		TArray<uint8> ReceiveBuffer;
		TArray<TSharedPtr<FTCPClient>> ClientDisconnected;

		FDateTime LastPing = FDateTime::Now();
		while (bShouldListen)
		{
			bool bHasPendingConnection;
			ListenSocket->HasPendingConnection(bHasPendingConnection);
			if (bHasPendingConnection)
			{
				TSharedPtr<FInternetAddr> Addr = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();
				FSocket* Client = ListenSocket->Accept(*Addr, TEXT("tcp-client"));

				const FString AddressString = Addr->ToString(true);

				TSharedPtr<FTCPClient> ClientItem = MakeShareable(new FTCPClient());
				ClientItem->Address = AddressString;
				ClientItem->Socket = Client;

				Clients.Add(AddressString, ClientItem);

				AsyncTask(ENamedThreads::GameThread, [&, AddressString]()
				{
					OnClientConnected.Broadcast(AddressString);
				});
			}

			for (auto ClientPair : Clients)
			{
				TSharedPtr<FTCPClient> Client = ClientPair.Value;

				ESocketConnectionState ConnectionState = Client->Socket->GetConnectionState();
				if (ConnectionState != ESocketConnectionState::SCS_Connected)
				{
					ClientDisconnected.Add(Client);
					continue;
				}

				if (Client->Socket->HasPendingData(BufferSize))
				{
					ReceiveBuffer.SetNumUninitialized(BufferSize);
					int32 Read = 0;

					Client->Socket->Recv(ReceiveBuffer.GetData(), ReceiveBuffer.Num(), Read);

					if (bReceiveDataOnGameThread)
					{
						TArray<uint8> ReceiveBufferGT;
						ReceiveBufferGT.Append(ReceiveBuffer);

						AsyncTask(ENamedThreads::GameThread, [&, ReceiveBufferGT]()
						{
							OnReceivedBytes.Broadcast(ReceiveBufferGT);
						});
					}
					else
					{
						OnReceivedBytes.Broadcast(ReceiveBuffer);
					}
				}

				if (bShouldPing)
				{
					FDateTime Now = FDateTime::Now();
					float TimeSinceLastPing = (Now - LastPing).GetTotalSeconds();

					if (TimeSinceLastPing > PingInterval)
					{
						LastPing = Now;
						int32 BytesSend = 0;
						bool Send = Client->Socket->Send(PingData.GetData(), PingData.Num(), BytesSend);
						if (!Send)
						{
							Client->Socket->Close();
						}
					}
				}
			}

			if(ClientDisconnected.Num() > 0)
			{
				for(TSharedPtr<FTCPClient> ClientToRemove : ClientDisconnected)
				{
					const FString Address = ClientToRemove->Address;
					Clients.Remove(Address);
					AsyncTask(ENamedThreads::GameThread, [this, Address]()
					{
						OnClientDisconnected.Broadcast(Address);
					});
				}
				ClientDisconnected.Empty();
			}

			FPlatformProcess::Sleep(0.0001);
		}

		for(auto ClientPair : Clients)
		{
			ClientPair.Value->Socket->Close();
		}
		Clients.Empty();

		AsyncTask(ENamedThreads::GameThread, [&, InListenPort]()
		{
			Clients.Empty();
			OnListenEnd.Broadcast(InListenPort);
		});
	});
}

void ATCPServer::StopListenServer()
{
	if (ListenSocket)
	{
		bShouldListen = false;
		OnListenEnd.Broadcast(ListenSocket->GetPortNo());
		ServerFinishedFuture.Get();

		ListenSocket->Close();
		ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->DestroySocket(ListenSocket);
		ListenSocket = nullptr;
	}
}

bool ATCPServer::Emit(const TArray<uint8>& Bytes, const FString& ToClient)
{
	if (Clients.Num() > 0)
	{
		int32 BytesSent = 0;
		if (ToClient == TEXT("All"))
		{
			bool bSuccess = true;
			TArray<TSharedPtr<FTCPClient>> AllClients;

			Clients.GenerateValueArray(AllClients);
			for (TSharedPtr<FTCPClient>& Client : AllClients)
			{
				if (Client.IsValid())
				{
					// FString str = TEXT("i am server!");
					// TCHAR* pSendData = str.GetCharArray().GetData();
					// int32 Strlen = FCString::Strlen(pSendData);
					// uint8* dst = (uint8*)TCHAR_TO_UTF8(pSendData);
					// bool bSend = Client->Socket->Send(dst, Strlen, BytesSent);
					bool bSend = Client->Socket->Send(Bytes.GetData(), Bytes.Num(), BytesSent);
					if (!bSend && bDisconnectOnFailedEmit)
					{
						Client->Socket->Close();
					}
					bSuccess = bSend && bSuccess;
				}
			}
			return bSuccess;
		}
		else
		{
			TSharedPtr<FTCPClient> Client = Clients[ToClient];
			if (Client.IsValid())
			{
				bool bSend = Client->Socket->Send(Bytes.GetData(), Bytes.Num(), BytesSent);
				if (bSend && bDisconnectOnFailedEmit)
				{
					Client->Socket->Close();
				}
				return bSend;
			}
		}
	}
	
	return false;
}

void ATCPServer::DisconnectClient(FString ClientAddress, bool bDisconnectNextTick)
{
	TFunction<void()> DisconnectFunction = [&, ClientAddress]
	{
		bool bDisconnectAll = ClientAddress == TEXT("All");
		if (!bDisconnectAll)
		{
			TSharedPtr<FTCPClient> Client = Clients[ClientAddress];
			if (Client.IsValid())
			{
				Client->Socket->Close();
				Clients.Remove(Client->Address);
				OnClientDisconnected.Broadcast(ClientAddress);
			}
		}
		else
		{
			for (auto ClientPair : Clients)
			{
				TSharedPtr<FTCPClient> Client = ClientPair.Value;
				Client->Socket->Close();
				Clients.Remove(Client->Address);
				OnClientDisconnected.Broadcast(ClientAddress);
			}
		}
	};

	if (bDisconnectNextTick)
	{
		AsyncTask(ENamedThreads::GameThread, DisconnectFunction);
	}
	else
	{
		DisconnectFunction();
	}
}



// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"

#include "TCPServer.h"
#include "GameFramework/Actor.h"
#include "TCPClient.generated.h"

UCLASS(Blueprintable)
class UESOCKET_API ATCPClient : public AActor
{
	GENERATED_BODY()
	
public:	
	// Sets default values for this actor's properties
	ATCPClient();

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;
	virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

public:	
	// Called every frame
	virtual void Tick(float DeltaTime) override;

	FTCPMessageSignature OnReceivedBytes;
	FTCPEventSignature OnConnected;
	FString ConnectionIP;
	int32 ConnectionPort;
	FString ClientSocketName;
	int32 BufferMaxSize;
	bool bShouldAutoConnectOnBeginPlay;
	bool bReceiveDataOnGameThread;
	bool bIsConnected;

	void ConnectToSocketAsClient(const FString& InIP = TEXT("127.0.0.1"), const int32 InPort = 3001);
	void CloseSocket();
	UFUNCTION(BlueprintCallable)
	bool Emit(const TArray<uint8>& Bytes);
private:
	FSocket* ClientSocket;
	FThreadSafeBool bShouldReceiveData;
	TFuture<void> ClientConnectionFinishedFuture;

	FString SocketDescription;
	TSharedPtr<FInternetAddr> RemoteAddress;
	
};


// Fill out your copyright notice in the Description page of Project Settings.


#include "TCPClient.h"

#include "UESocket.h"

// Sets default values
ATCPClient::ATCPClient()
{
	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	bShouldAutoConnectOnBeginPlay = false;
	bReceiveDataOnGameThread = true;
	ConnectionIP = FString(TEXT("127.0.0.1"));
	ConnectionPort = 3001;
	ClientSocketName = FString(TEXT("ue4-tcp-client"));
	ClientSocket = nullptr;

	BufferMaxSize = 2 * 1024 * 1024;
}

// Called when the game starts or when spawned
void ATCPClient::BeginPlay()
{
	Super::BeginPlay();
	if (bShouldAutoConnectOnBeginPlay)
	{
		ConnectToSocketAsClient(ConnectionIP, ConnectionPort);
	}
}

void ATCPClient::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
	Super::EndPlay(EndPlayReason);
	CloseSocket();
}

// Called every frame
void ATCPClient::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
}

void ATCPClient::ConnectToSocketAsClient(const FString& InIP, const int32 InPort)
{
	RemoteAddress = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();

	bool bIsValid;
	RemoteAddress->SetIp(*InIP, bIsValid);
	RemoteAddress->SetPort(InPort);

	if (!bIsValid)
	{
		UE_LOG(LogTemp, Error, TEXT("TCP address is invalid <%s:%d>"), *InIP, InPort);
		return;
	}

	ClientSocket = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateSocket(NAME_Stream, ClientSocketName, false);

	ClientSocket->SetSendBufferSize(BufferMaxSize, BufferMaxSize);
	ClientSocket->SetReceiveBufferSize(BufferMaxSize, BufferMaxSize);

	bIsConnected = ClientSocket->Connect(*RemoteAddress);
	if (bIsConnected)
	{
		OnConnected.Broadcast(InPort);
	}
	bShouldReceiveData = true;

	ClientConnectionFinishedFuture = ThreadUtility::RunLambdaOnBackgroundThread([&]()
	{
		uint32 BufferSize = 0;
		TArray<uint8> ReceiveBuffer;
		while (bShouldReceiveData)
		{
			if (ClientSocket->HasPendingData(BufferSize))
			{
				ReceiveBuffer.SetNumUninitialized(BufferSize);
				int32 Read = 0;
				ClientSocket->Recv(ReceiveBuffer.GetData(), ReceiveBuffer.Num(), Read);

				if (bReceiveDataOnGameThread)
				{
					TArray<uint8> ReceiveBufferGT;
					ReceiveBufferGT.Append(ReceiveBuffer);

					AsyncTask(ENamedThreads::GameThread, [&, ReceiveBufferGT]()
					{
						OnReceivedBytes.Broadcast(ReceiveBufferGT);
			
					});
				}
				else
				{
					OnReceivedBytes.Broadcast(ReceiveBuffer);
				}
			}
			ClientSocket->Wait(ESocketWaitConditions::WaitForReadOrWrite, FTimespan(1));
		}
		
	});
	
}

void ATCPClient::CloseSocket()
{
	if (ClientSocket)
	{
		bShouldReceiveData = false;
		ClientConnectionFinishedFuture.Get();

		ClientSocket->Close();
		ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->DestroySocket(ClientSocket);
		ClientSocket = nullptr;
	}
}

bool ATCPClient::Emit(const TArray<uint8>& Bytes)
{
	if (ClientSocket && ClientSocket->GetConnectionState() == SCS_Connected)
	{
		int32 BytesSent = 0;
		return ClientSocket->Send(Bytes.GetData(), Bytes.Num(), BytesSent);
	}
	return false;
}

#1. 演示视频
链接：https://pan.baidu.com/s/1UJ8zn0fBIW4eNxYqRo-Mqw
提取码：hy4s

#2. 源码白给
链接：https://pan.baidu.com/s/1BRUfE6U7_2GceVLt1tsRNQ?pwd=0sx4
提取码：0sx4

UnrealEngine（11）：网络编程与多人游戏开发教程
kkchenjj的博客
07-23 1372
在Unreal Engine中，自定义网络复制允许开发者精确控制哪些数据在网络中复制，以及如何复制。这对于优化网络性能和确保游戏状态的一致性至关重要。定义网络复制属性：在Actor或Component中，使用REPLICATE宏标记需要在网络间同步的变量。实现复制逻辑：通过重写函数，返回一个包含所有需要复制属性的数组。使用RPCs（远程过程调用）：RPCs允许服务器执行一个函数，并在所有客户端上复制其效果，这对于同步玩家动作或游戏事件非常有用。
Ue4游戏服务器性能压测,UE4学习笔记（17）Socket测试
weixin_42188512的博客
08-06 1409
本篇文章和大家大家分享的是UE4中Socket测试，不过仅作简单测试，尚未进行多线程测试。环境：win10 64bitUE4.15纯win32 console application客户端 / 服务端 (阻塞通信)服务端测试代码：// SocketTest.cpp : Defines the entry point for the console application.#include "std...
UE4 使用Socket
qqQQqsadfj的博客
11-02 2348
通过传过来的IP与端口号进行一个绑定，第一行就是将BindIP分割然后分别放进ip的四个值内（A,B,C,D），然后创建一个FInternetAddr类型的智能指针，将ip的值与外界传来的端口号对FInternetAddr进行一个初始化赋值，最后对让socket对地址进行一个绑定。FSocket::HasPendingData将返回一个值，通知您是否。服务器进行一个监听，看客户端是否发出消息让服务器进行接收。客户端发送消息，先将要发送的字符串进行char的转化。然后对处理后的数据发送到指定地址。
UE4/5 C++网络服务器编程纪录【零】--准备篇
blind_monkey的博客
03-26 2986
UE4/5 C++网络服务器编程纪录
UE 4 TCP socket客户端，（TCP socket 插件）
qq_45988507的博客
03-17 4273
在.h中 UCLASS() class EXAMPLE_API ACppSocketConnection : public ATcpSocketConnection { GENERATED_BODY() public: UFUNCTION() void OnConnected(int32 ConnectionId); UFUNCTION() void OnDisconnected(int32 ConId); UFUNCTION() void OnMessageReceived(int
记个笔记：UE Thread&Socket
m0_60846226的博客
12-22 672
最近学习`UE`学到了多线程和`Socket`的内容，将学到的东西整理一下，记个笔记！！！
UE4 TCP连接 客户端 服务器 C++项目实例
08-23
在本项目中，"UE4 TCP连接 客户端 服务器 C++项目实例" 是一个基于虚幻引擎4（UE4）开发的网络通信应用，它利用C++语言实现了TCP（传输控制协议）的客户端与服务器功能。TCP是一种面向连接的、可靠的、基于字节流的...
UE4网络同步(二)——深入同步细节
热门推荐
Jerish的博客
10-29 2万+
前言 UE同步是一块比较复杂而庞大的模块，里面设计到了很多设计思想，技巧，技术。我这里主要是从同步的流程分析，以同步的机制为讲解核心，给大家描述里面是怎么同步的，会大量涉及UE同步模块的底层代码，稍微涉及一点计算机网络底层（Socket相关）相关的知识。 PS：如果只是想知道怎么使用同步，不建议阅读这篇文章，不过可以参考我另外一篇博客 UE4网络同步(一)——理解同步规则 另外，博主参考的源...
UE：网络架构
Taopper的博客
06-08 931
网络同步，就是使各个客户端上的角色表现保持一致，属于游戏引擎的高级功能，所以一般我们都将其归于Gameplay模块当中。不过具体的实现方案其实会深刻影响到底层的网络架构（甚至是整个游戏架构），我们既要决定通过哪种网络协议来完成，又要决定游戏各个模块的循环执行顺序，其实已经不单单是“Gameplay”层面的东西了。虚幻引擎属于标准的CS架构（经过无数次改版的），内置状态同步功能，其同步频率与游戏的帧率相同，属于变长步更新。由于帧率完全受CPU、GPU性能的影响，所以网络同步的频率与整个项目的性能息息相关。..
【UE4中的网络编程概述】UE4网络类和接口：介绍主要网络相关的类和接口
在介绍Unreal Engine 4（简称UE4）网络编程的基础知识之前，我们需要了解网络编程的基本概念。网络编程主要涉及网络通信协议、网络数据的封装、发送、接收以及同步等方面。它允许软件应用通过网络
深入浅出UE4网络 - Leonhard
10-25
深入浅出UE4网络 - Leonhard- - 博客园的文章集合。哦哦哦
UE4 Socket多线程非阻塞通信【1】
迷雾森林的专栏
01-18 1万+
昨日不可追,今日尤可为.勤奋,炽诚,不忘初心 前面写了一篇有关于虚幻4加载第三方库的博客思前顾后,感觉细节还是有必要拎起来注意下. ue4自带的Fsocket用起来依旧不是那么的顺手,感觉超出了我的理解范围了.另外我也不想让我近一个礼拜研究的C++ Socket无用武之地,毅然决然的决定使用自己的C++通讯库.再美再豪华的别墅真不如自己亲手搭建的草庐来的舒畅.这就好比我表弟...
UE5- c++ websocket客户端写法
xubaoyong的专栏
08-28 3587
通过该例子我们学到了websocket,json的应用还学到的两种打印log的方法。
ue4打包安卓发送udp报文_UE4 socket UDP通信
weixin_29499829的博客
12-28 548
最近公司项目要用广播通信 写了一个socket udp通信 最后项目还是用unity 没用上 所以拿出来和大家分享下server.jpg (353.71 KB, 下载次数: 233)2017-3-1 09:45 上传这个是接收端的client.jpg (365.79 KB, 下载次数: 230)2017-3-1 09:45 上传这个是客户端的 图上这个是发给指定ip的要给局域网广播的话 将ip...
UE4 Socket多线程非阻塞通信【2】
迷雾森林的专栏
01-18 6538
昨日不可追,今日尤可为.勤奋,炽诚,不忘初心 紧接着第一部分,别说话,勿打断我游离的思绪我们走我们走... 二.消息结构&收发队列 先不急着往下走,先捋一捋,不知道自己要干什么地走下去是一件很可怕的事情. 首先,我们需要一个通讯接口,即socket.通讯有两种模式,一种是阻塞通讯,另一种是非阻塞通讯. 阻塞通讯:一直卡在那儿,直到处理完了再返回.比如我要...
UE4之网络编程--连接自定义服务器
m0_67390379的博客
04-11 1532
转载学习：http://blog.csdn.net/pizi0475/article/details/51780574 在虚幻引擎中连接自定义服务器 UE4 dedicated server是一个很好的游戏服务器,但是对于大厅和聊天服务器来说,我们要自行开发,通过UE4的socket组建很方便的和其他服务器建立连接 创建Socket FSocket* Socket = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateSocket(NAME_
UE4网络编程学习之路02----网络架构、通信
ccsu_deer
06-03 893
Server-Client架构 一个服务器，一个或多个客户端 不能信任客户端，所有重要信息都需要通过服务器验证 Listen Server
网络编程
nicolelili1的专栏
01-11 369
一、什么是网络 在计算机领域中，网络是信息传输、接收、共享的虚拟平台 二、什么是网络编程 网络编程从大的方面来说就是对信息的发送到接收。 通过操作相应的Api调度计算机硬件资源，并利用传输管道进行数据交换的过程 更为具体的涉及：网络模型、套接字、数据包 三、7层网络模型-OSI 上图是两台电脑发送、接收的过程： 表示层（Presentation）：应用层（Applicat...
UE4 TCP Socket Plugins 功能应用
Creator丶小鑫的博客
11-15 6123
今天呢想做一个数据通信的功能，但是又懒得写Socket插件了，想着白嫖一个吧，找了一上午没找到关于UE 4.27版本的插件UDP和TCP插件，找到的也就是4.26的插件，编译呢又嫌麻烦，那就接着白嫖呗，反正也就是小功能测试。后来在UE商城里面找到了这个TCP Socket Plugins得插件，我这里就简单的进行数据关联，多线程的绑定呢你们自己看下哈这是他Github地址有兴趣的自己搞下。 第一步将这个插件安装到你需要的引擎版本下，然后创建一个工程，蓝图c++的无所谓，我这里是个蓝图的4.27.1的项
UE5 Simple UDP TCP Socket
最新发布
04-03
### UE5中的UDP和TCP Socket通信 在Unreal Engine 5 (UE5) 中，可以通过使用 `FSocket` 和其他网络类来实现简单的 UDP 或 TCP 套接字通信。这些功能位于引擎的核心库中，并提供了创建客户端和服务端所需的工具。 #### 创建一个基本的TCP服务器 要设置一个基础的TCP服务器，可以按照以下方式操作： 1. **初始化套接字子系统** 需要在应用程序启动时调用 `ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)` 来获取当前平台支持的套接字子系统实例[^1]。 2. **绑定监听地址** 使用 `CreateListenerSocket` 方法创建并绑定到指定IP和端口上的侦听器套接字[^2]。 3. **接受连接请求** 当有新连接到来时，通过异步线程处理传入的数据流或者直接读取数据缓冲区的内容[^3]。 以下是用于构建简单TCP Server的一个代码片段示例： ```cpp void StartTCPServer(const FString& InAddress, int32 Port) { ISocketSubsystem* SocketSubSystem = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM); // Create a new IPv4 address from the given string representation. TSharedRef<FInternetAddr> LocalAddr = SocketSubSystem->CreateInternetAddr(); bool bIsValid; uint8 IpVersion = EIpVersion::IPv4; FIPv4Address IPValue; FIPv4Address::Parse(InAddress, IPValue); LocalAddr->SetIp(IPValue.Value, &bIsValid); check(bIsValid); LocalAddr->SetPort(Port); ListenerSocket = SocketSubSystem->CreateSocket(NAME_Stream, TEXT("Default"), false); if (!ListenerSocket.IsValid()) return; ListenerSocket->Bind(*LocalAddr); } ``` #### 实现UDP广播消息发送/接收 对于UDP协议来说，则不需要建立持久性的链接关系即可互相传递信息包。下面是如何配置以及收发UDP数据报的方法概述: - 调用 `CreateSocket` 函数生成一个新的无连接模式下的socket对象。 - 设置该socket为非阻塞状态以便于多任务并发执行效率更高。 - 利用SendTo函数向目标主机投递特定长度的消息体；而ReceiveFrom则负责捕获来自外部源节点的信息帧。 这里给出一段关于如何利用C++编写简易版UDP Client的例子: ```cpp bool SendUDPMessage(FString MessageToSend, const FString& TargetIPAddress, int32 TargetPort) { ISocketSubsystem* SocketSubsystem = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM); if(!SocketSubsystem){ return false; } TUniquePtr<FSocket> UDPSocket = nullptr; UDPSocket.Reset(SocketSubsystem->CreateSocket(NAME_DGram,"TempUDPSocket",false)); if(!UDPSocket || !UDPSocket->IsValid()){ return false; } TArray<uint8> OutgoingData; OutgoingData.AddZeroed(MessageToSend.Len()); FCStringAnsi::Strncpy((ANSICHAR*)OutgoingData.GetData(),TCHAR_TO_UTF8(*MessageToSend),MessageToSend.Len()); FInetAddress RecipientAddress; RecipientAddress.SetIp(TargetIPAddress); RecipientAddress.SetPort(TargetPort); int32 BytesSent=0; bool SuccessFlag = UDPSocket->SendTo(RecipientAddress,(uint8*)&OutgoingData[0],OutgoingData.Num(),BytesSent); return SuccessFlag && (BytesSent == OutgoingData.Num()); } ``` 以上就是有关于UE5环境下搭建起基础形式下两种不同类型的sockets解决方案介绍[^4].
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值