Unity Realtime Multiplayer, Part 2: TCP, UDP, WebSocket Protocols

My s on the Unity Networking Landscape in 2023 continues! Today's post will cover the data transmission protocols utilized in real-time multiplayer games. series of article Greetings everyone! I'm Dmitrii Ivashchenko, a Lead Software Engineer at MY.GAMES. We'll start with a brief overview of what protocols exist at different levels of network interaction. Content Overview OSI Levels Transmission Control Protocol TCP Client TCP Server User Datagram Protocol UDP client UDP Server Websocket Websocket Client Websocket Server Conclusion OSI Levels The OSI (Open Systems Interconnection) model is a conceptual model that characterizes and standardizes the functions of a communication system in terms of abstraction levels. This model was developed by the International Organization for Standardization (ISO) in 1978. It consists of seven layers: : This layer deals with the transmission and reception of raw bits over the channel. Protocols at this layer describe the physical interface and the characteristics of the medium, including bit representations, transmission rates, physical cables, cards, and connector designs. Physical Layer : This layer provides data transfer across the physical medium and handles errors that may occur at the physical level. Data Link Layer : This layer determines the path (routing) for data transmission between networks. Network Layer : This layer manages message delivery between points and provides reliability if necessary. Transport Layer : This layer manages session establishment, maintenance, and termination between users and applications. Session Layer : This layer ensures data independence from differences in data representation (encoding) on the sender and receiver sides. Presentation Layer : This layer includes protocols that have a direct relation to the applications that the user interacts with. Application Layer It's worth noting that each layer builds upon the previous one. Layers above the Transport layer (Session, Presentation, and Application) are highly specialized and cannot help us organize real-time multiplayer. Therefore, we have to stop at the Transport Layer and use its TCP and UDP protocols for optimal data exchange between players. Transmission Control Protocol is a connection-oriented protocol, which means that communication occurs between two devices that establish a connection to exchange data. This protocol ensures reliability because it guarantees that all transmitted data will reach its destination in the correct order. If any data is lost during transmission, TCP will automatically retry the request until all data is successfully transmitted. TCP Establishing a connection involves the following steps: The client and server create sockets for exchanging data over TCP. The client sends a SYN (synchronization) segment to the server with a specified destination port. The server accepts the SYN segment, creates its own socket, and sends a SYN-ACK (synchronization-acknowledgment) segment to the client. The client accepts the SYN-ACK segment and sends an ACK (acknowledgment) segment to the server to complete the connection establishment process. A reliable two-way connection is now established. TCP Client The example below shows a basic implementation of a TCP client and can be extended to work with specific data and game logic. The code connects to a server with a specified IP address and port, and then sends and receives data through the connection. A network stream is used for asynchronous data reception from the server. using System; using System.Net; using System.Net.Sockets; using UnityEngine; public class TCPClient : MonoBehaviour { private TcpClient tcpClient; private NetworkStream networkStream; private byte[] receiveBuffer; private void Start() { // Example: Connect to server with IP address 127.0.0.1 (localhost) and port 5555 ConnectToServer("127.0.0.1", 5555); } private void ConnectToServer(string ipAddress, int port) { tcpClient = new TcpClient(); tcpClient.Connect(IPAddress.Parse(ipAddress), port); networkStream = tcpClient.GetStream(); // Start asynchronous operation to receive data from the server receiveBuffer = new byte[tcpClient.ReceiveBufferSize]; networkStream.BeginRead(receiveBuffer, 0, receiveBuffer.Length, ReceiveData, null); } private void ReceiveData(IAsyncResult result) { int bytesRead = networkStream.EndRead(result); byte[] receivedBytes = new byte[bytesRead]; Array.Copy(receiveBuffer, receivedBytes, bytesRead); string receivedMessage = System.Text.Encoding.UTF8.GetString(receivedBytes); Debug.Log("Received from server: " + receivedMessage); // Continue the asynchronous operation to receive data networkStream.BeginRead(receiveBuffer, 0, receiveBuffer.Length, ReceiveData, null); } private void SendData(string message) { byte[] sendBytes = System.Text.Encoding.UTF8.GetBytes(message); networkStream.Write(sendBytes, 0, sendBytes.Length); networkStream.Flush(); } } The method establishes a connection to the server at the specified IP address and port. Data reception from the server is carried out in the method , while data transmission is done in the method . The received data is output to the console using . ConnectToServer(string ipAddress, int port) ReceiveData(IAsyncResult result) SendData(string message) Debug.Log TCP Server The code example below represents a simple TCP server in Unity. The code initializes the server, listens to the specified port, and accepts incoming connections from clients. After connecting to a client, the server sends and receives data through the network stream. The method initializes the server on the specified port and begins listening for incoming connections. When a client connection is established, the method is executed, which receives data from the client and starts an asynchronous operation to receive data. StartServer(int port) HandleIncomingConnection(IAsyncResult result) The received data is processed in the method. After receiving data from the client, the server can perform the necessary processing or send data back to the client. ReceiveData(IAsyncResult result) The method sends data to the client through the network stream. The data is converted into a byte array and sent to the client. SendData(string message) using System; using System.Net; using System.Net.Sockets; using UnityEngine; public class TCPServer : MonoBehaviour { private TcpListener tcpListener; private TcpClient connectedClient; private NetworkStream networkStream; private byte[] receiveBuffer; private void Start() { // Example: Start the server on port 5555 StartServer(5555); } private void StartServer(int port) { tcpListener = new TcpListener(IPAddress.Any, port); tcpListener.Start(); Debug.Log("Server started. Waiting for connections..."); // Start accepting client connections asynchronously tcpListener.BeginAcceptTcpClient(HandleIncomingConnection, null); } } The method is used to handle an incoming client connection. After accepting a connection, it obtains a stream for data exchange with the client and initiates an asynchronous operation to receive data from the client. HandleIncomingConnection Then, the method creates a buffer for receiving data, based on the buffer size received from the connected client. An asynchronous operation is launched to read data from the stream using the created buffer. After the read operation completes, the data will be passed to the method for further processing. ReceiveData Also, the method launches another asynchronous operation to accept incoming connections for the possibility of accepting the next client. When a client connects to the server, this method will be called to handle the connection, and the server will be ready to asynchronously accept the next clients. private void HandleIncomingConnection(IAsyncResult result) { connectedClient = tcpListener.EndAcceptTcpClient(result); networkStream = connectedClient.GetStream(); Debug.Log("Client connected: " + connectedClient.Client.RemoteEndPoint); // Start asynchronous operation to receive data from the client receiveBuffer = new byte[connectedClient.ReceiveBufferSize]; networkStream.BeginRead(receiveBuffer, 0, receiveBuffer.Length, ReceiveData, null); // Accept next client connection asynchronously tcpListener.BeginAcceptTcpClient(HandleIncomingConnection, null); } The method is used to process the received data from the client. After the data reading operation is completed, the method checks the number of bytes read. If the number of bytes is less than or equal to zero, this means that the client has disconnected. In this case, the method closes the connection with the client and terminates execution. ReceiveData If the number of bytes read is greater than zero, the method creates a byte array for the received data and copies the read data into this array. Then, the method converts the received bytes to a string using the UTF-8 encoding and outputs the received message to the console. private void ReceiveData(IAsyncResult result) { int bytesRead = networkStream.EndRead(result); if (bytesRead <= 0) { Debug.Log("Client disconnected: " + connectedClient.Client.RemoteEndPoint); connectedClient.Close(); return; } byte[] receivedBytes = new byte[bytesRead]; Array.Copy(receiveBuffer, receivedBytes, bytesRead); string receivedMessage = System.Text.Encoding.UTF8.GetString(receivedBytes); Debug.Log("Received from client: " + receivedMessage); // Process received data // Continue the asynchronous operation to receive data networkStream.BeginRead(receiveBuffer, 0, receiveBuffer.Length, ReceiveData, null); } private void SendData(string message) { byte[] sendBytes = System.Text.Encoding.UTF8.GetBytes(message); networkStream.Write(sendBytes, 0, sendBytes.Length); networkStream.Flush(); Debug.Log("Sent to client: " + message); } The method is used to send data to the client. It converts the message string to a byte array using the UTF-8 encoding and writes this array to the network stream. After sending the data, the method clears the stream and outputs the sent message to the console. SendData Although reliability may sound like a big plus, this TCP feature can create problems in real-time multiplayer games. Data transmission in TCP can be slowed down by the mechanism of retransmission and flow control, which can lead to delays or "lags". User Datagram Protocol UDP is a simpler protocol that does not guarantee delivery or packet order. This makes it much faster than TCP, as it does not spend time establishing a connection or retransmitting lost packets. Due to its speed and simplicity, UDP is often used in network games and other applications that require real-time data transmission. However, using UDP requires developers to manage data transmission more carefully. Since UDP does not guarantee delivery, you may need to implement your own mechanisms to handle lost packets or packets that arrived out of order. UDP Client This code demonstrates a basic implementation of a UDP client in Unity. The method initializes the UDP client and connects it to the remote server specified by the IP address and port. The client starts receiving data asynchronously using the method and sends a message to the server using the method. StartUDPClient BeginReceive SendData using System; using System.Net; using System.Net.Sockets; using UnityEngine; public class UDPExample : MonoBehaviour { private UdpClient udpClient; private IPEndPoint remoteEndPoint; private void Start() { // Example: Start the UDP client and connect to the remote server StartUDPClient("127.0.0.1", 5555); } private void StartUDPClient(string ipAddress, int port) { udpClient = new UdpClient(); remoteEndPoint = new IPEndPoint(IPAddress.Parse(ipAddress), port); // Start receiving data asynchronously udpClient.BeginReceive(ReceiveData, null); // Send a message to the server SendData("Hello, server!"); } private void ReceiveData(IAsyncResult result) { byte[] receivedBytes = udpClient.EndReceive(result, ref remoteEndPoint); string receivedMessage = System.Text.Encoding.UTF8.GetString(receivedBytes); Debug.Log("Received from server: " + receivedMessage); // Continue receiving data asynchronously udpClient.BeginReceive(ReceiveData, null); } private void SendData(string message) { byte[] sendBytes = System.Text.Encoding.UTF8.GetBytes(message); // Send the message to the server udpClient.Send(sendBytes, sendBytes.Length, remoteEndPoint); Debug.Log("Sent to server: " + message); } } When data is received from the server, the method is invoked, which processes the received bytes and converts them into a string. The received message is then logged to the console. The client continues to receive data asynchronously by calling again. ReceiveData BeginReceive The method converts the message into bytes and sends it to the server using the method of the UDP client. SendData Send UDP Server This code demonstrates a basic implementation of a UDP server in Unity. The the method initializes the UDP server on the specified port and starts receiving data asynchronously using the method. StartUDPServer BeginReceive When data is received from a client, the method is invoked, which processes the received bytes and converts them into a string. The received message is then logged to the console. The server continues to receive data asynchronously by calling again. ReceiveData BeginReceive using System; using System.Net; using System.Net.Sockets; using UnityEngine; public class UDPServer : MonoBehaviour { private UdpClient udpServer; private IPEndPoint remoteEndPoint; private void Start() { // Example: Start the UDP server on port 5555 StartUDPServer(5555); } private void StartUDPServer(int port) { udpServer = new UdpClient(port); remoteEndPoint = new IPEndPoint(IPAddress.Any, port); Debug.Log("Server started. Waiting for messages..."); // Start receiving data asynchronously udpServer.BeginReceive(ReceiveData, null); } private void ReceiveData(IAsyncResult result) { byte[] receivedBytes = udpServer.EndReceive(result, ref remoteEndPoint); string receivedMessage = System.Text.Encoding.UTF8.GetString(receivedBytes); Debug.Log("Received from client: " + receivedMessage); // Process the received data // Continue receiving data asynchronously udpServer.BeginReceive(ReceiveData, null); } private void SendData(string message, IPEndPoint endPoint) { byte[] sendBytes = System.Text.Encoding.UTF8.GetBytes(message); // Send the message to the client udpServer.Send(sendBytes, sendBytes.Length, endPoint); Debug.Log("Sent to client: " + message); } } The method takes a message and an representing the client's address and port. It converts the message into bytes and sends it to the client using the method of the UDP server. SendData IPEndPoint Send In the context of game development, the choice between TCP and UDP largely depends on the type of your game. If your game requires reliable data delivery and response time is not a critical factor (for example, in real-time strategy or turn-based games), then TCP may be a suitable choice. On the other hand, if your game requires fast data transmission and can handle some data loss (for example, in first-person shooters or racing games), then UDP may be the best choice. WebSocket is a communication protocol that allows the establishment of a persistent connection between a browser and a server. The main difference from regular HTTP is that it enables bidirectional communication; the server is able, not only to respond to client requests, it can also send messages to it. WebSocket WebSocket is an application-level protocol based on TCP. It supports messages, not streams, which distinguishes it from regular TCP. WebSocket includes additional functionality that can add some performance overhead. Here's how it works, step by step: The client sends a special HTTP request called an "Upgrade request." This request informs the server that the client wants to switch to WebSocket. If the server supports WebSocket and agrees to switch, it responds with a special HTTP response that confirms the upgrade to WebSocket. After exchanging these messages, a persistent, bidirectional connection is established between the client and the server. Both sides can send messages at any time, not just in response to requests from the other side. Now the client and server can send and receive messages at any time. Each WebSocket message is wrapped in "frames" that indicate when the message starts and ends. This allows the browser and server to correctly interpret messages, even if they arrive in a mixed order or are split into parts due to network issues. Either side can close the connection at any time by sending a special "close connection" frame. The other side can respond with a confirmation of the closure, and after that, both sides must immediately stop sending any other data. Status codes can also be used to indicate the reason for closure. WebSocket Client The code below provides an example of implementing a WebSocket client in Unity using C# language and the library. WebSocketSharp In the method, which is called upon object initialization, a new instance of is created, initialized with the address of your WebSocket server. Start() WebSocket After that, event handlers and are set up. OnOpen OnMessage using UnityEngine; using WebSocketSharp; public class WebSocketClient : MonoBehaviour { private WebSocket ws; void Start() { ws = new WebSocket("ws://your-websocket-server-url/Auth"); ws.OnOpen += OnOpenHandler; ws.OnMessage += OnMessageHandler; ws.ConnectAsync(); } private void OnOpenHandler(object sender, System.EventArgs e) { var data = "Player1"; ws.Send(data) } private void OnMessageHandler(object sender, MessageEventArgs e) { Debug.Log("WebSocket server said: " + e.Data); } } is triggered when a connection is established with the server. In this example, when the connection is established, a message with the text "Player1" is sent to the server. OnOpen is triggered when a message is received from the server. Here, upon receiving a message, its content is displayed in the console. OnMessage Then, the method is called, which asynchronously connects to the server. ConnectAsync() WebSocket Server The code below is an example of creating a WebSocket server. In the method, which is called when the object is initialized, a new instance of is created, initialized with the address of your WebSocket server. Then the WebSocket service is added to the server, available at the path. After that, the server is started using the method. Start() WebSocketServer AuthBehaviour /Auth Start() using UnityEngine; using WebSocketSharp; using WebSocketSharp.Server; public class WebSocketServer : MonoBehaviour { void Start() { var socket = new WebSocketServer("ws://your-websocket-server-url"); socket.AddWebSocketService ("/Auth"); socket.Start(); } } public class AuthBehaviour : WebSocketBehavior { protected override void OnMessage (MessageEventArgs e) { var playerName = e.Data; Debug.Log("WebSocket client connected: " + playerName); Send("Auth Complete: " + playerName); } } is a class derived from that defines the server behavior when receiving messages from clients. Here, the method is overridden, which is called when the server receives a message from a client. AuthBehaviour WebSocketBehavior OnMessage() In this method, the message text is first extracted, then a message is output to the console indicating which client has connected, using the name passed in the message. Then, the server sends a message back to the client containing information about the completion of the authentication. Conclusion We've discussed how to create connections for Unity games using TCP, UDP, and WebSockets, as well as the advantages and disadvantages of each. Despite the lightweight nature of UDP and the reliability of TCP, neither is a good choice for organizing real-time multiplayer in games. UDP will lose some data, and TCP will not provide the necessary transmission speed. In the next article, we will discuss how to organize reliable data transmission using UDP.

HackerNoon Mobile

Unity Realtime Multiplayer, Part 2: TCP, UDP, WebSocket Protocols

Too Long; Didn't Read

@dmitrii

Credibility

RELATED STORIES