Unity Realtime Multiplayer, Teil 2: TCP-, UDP- und WebSocket-Protokolle

Meine Artikelserie zur Unity-Netzwerklandschaft im Jahr 2023 geht weiter! Der heutige Beitrag befasst sich mit den Datenübertragungsprotokollen, die in Echtzeit-Multiplayer-Spielen verwendet werden.

Grüße an alle! Ich bin Dmitrii Ivashchenko, leitender Softwareentwickler bei MY.GAMES. Wir beginnen mit einem kurzen Überblick darüber, welche Protokolle auf verschiedenen Ebenen der Netzwerkinteraktion vorhanden sind.

Inhaltsübersicht

• OSI-Ebenen
• Übertragungskontrollprotokoll
  • TCP-Client
  • TCP-Server
• Benutzer-Datagramm-Protokoll
  • UDP-Client
  • UDP-Server
• Websocket
  • Websocket-Client
  • Websocket-Server
• Abschluss

OSI-Ebenen

Das OSI-Modell (Open Systems Interconnection) ist ein konzeptionelles Modell, das die Funktionen eines Kommunikationssystems anhand von Abstraktionsebenen charakterisiert und standardisiert. Dieses Modell wurde 1978 von der International Organization for Standardization (ISO) entwickelt.

Es besteht aus sieben Schichten:

1. Physikalische Schicht : Diese Schicht befasst sich mit der Übertragung und dem Empfang von Rohbits über den Kanal. Protokolle auf dieser Ebene beschreiben die physische Schnittstelle und die Eigenschaften des Mediums, einschließlich Bitdarstellungen, Übertragungsraten, physische Kabel, Karten und Steckerdesigns.

   
   

2. Datenverbindungsschicht : Diese Schicht ermöglicht die Datenübertragung über das physische Medium und behandelt Fehler, die auf der physischen Ebene auftreten können.

   
   

3. Netzwerkschicht : Diese Schicht bestimmt den Pfad (Routing) für die Datenübertragung zwischen Netzwerken.

   
   

4. Transportschicht : Diese Schicht verwaltet die Nachrichtenübermittlung zwischen Punkten und sorgt bei Bedarf für Zuverlässigkeit.

   
   

5. Sitzungsschicht : Diese Schicht verwaltet den Aufbau, die Aufrechterhaltung und die Beendigung von Sitzungen zwischen Benutzern und Anwendungen.

   
   

6. Präsentationsschicht : Diese Schicht stellt die Unabhängigkeit der Daten von Unterschieden in der Datendarstellung (Kodierung) auf Sender- und Empfängerseite sicher.

   
   

7. Anwendungsschicht : Diese Schicht umfasst Protokolle, die einen direkten Bezug zu den Anwendungen haben, mit denen der Benutzer interagiert.

Es ist erwähnenswert, dass jede Ebene auf der vorherigen aufbaut. Schichten über der Transportschicht (Sitzung, Präsentation und Anwendung) sind hochspezialisiert und können uns nicht bei der Organisation von Echtzeit-Multiplayer helfen. Deshalb müssen wir beim Transport Layer anhalten und dessen TCP- und UDP-Protokolle für einen optimalen Datenaustausch zwischen Spielern nutzen.

Übertragungskontrollprotokoll

TCP ist ein verbindungsorientiertes Protokoll, was bedeutet, dass die Kommunikation zwischen zwei Geräten erfolgt, die eine Verbindung zum Datenaustausch herstellen. Dieses Protokoll gewährleistet Zuverlässigkeit, da es garantiert, dass alle übertragenen Daten in der richtigen Reihenfolge ihr Ziel erreichen. Wenn während der Übertragung Daten verloren gehen, versucht TCP die Anfrage automatisch erneut, bis alle Daten erfolgreich übertragen wurden.

Der Verbindungsaufbau umfasst die folgenden Schritte:

• Client und Server erstellen Sockets für den Datenaustausch über TCP.
• Der Client sendet ein SYN-Segment (Synchronisation) mit einem angegebenen Zielport an den Server.
• Der Server akzeptiert das SYN-Segment, erstellt einen eigenen Socket und sendet ein SYN-ACK-Segment (Synchronisationsbestätigung) an den Client.
• Der Client akzeptiert das SYN-ACK-Segment und sendet ein ACK-Segment (Bestätigung) an den Server, um den Verbindungsaufbau abzuschließen. Eine zuverlässige Zwei-Wege-Verbindung ist nun hergestellt.

TCP-Client

Das folgende Beispiel zeigt eine grundlegende Implementierung eines TCP-Clients und kann erweitert werden, um mit bestimmten Daten und Spiellogik zu arbeiten.

Der Code stellt eine Verbindung zu einem Server mit einer angegebenen IP-Adresse und einem angegebenen Port her und sendet und empfängt dann Daten über die Verbindung. Für den asynchronen Datenempfang vom Server wird ein Netzwerkstream verwendet.

 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(); } }

Die Methode ConnectToServer(string ipAddress, int port) stellt eine Verbindung zum Server an der angegebenen IP-Adresse und dem angegebenen Port her. Der Datenempfang vom Server erfolgt in der Methode ReceiveData(IAsyncResult result) , während die Datenübertragung in der Methode SendData(string message) erfolgt. Die empfangenen Daten werden mittels Debug.Log an die Konsole ausgegeben.

TCP-Server

Das folgende Codebeispiel stellt einen einfachen TCP-Server in Unity dar. Der Code initialisiert den Server, lauscht auf den angegebenen Port und akzeptiert eingehende Verbindungen von Clients. Nach der Verbindung mit einem Client sendet und empfängt der Server Daten über den Netzwerkstream.

Die Methode StartServer(int port) initialisiert den Server am angegebenen Port und beginnt, auf eingehende Verbindungen zu warten. Wenn eine Clientverbindung hergestellt wird, wird die Methode HandleIncomingConnection(IAsyncResult result) ausgeführt, die Daten vom Client empfängt und einen asynchronen Vorgang zum Empfangen von Daten startet.

Die empfangenen Daten werden in der Methode ReceiveData(IAsyncResult result) verarbeitet. Nach dem Empfang der Daten vom Client kann der Server die erforderliche Verarbeitung durchführen oder Daten an den Client zurücksenden.

Die Methode SendData(string message) sendet Daten über den Netzwerkstream an den Client. Die Daten werden in ein Byte-Array umgewandelt und an den Client gesendet.

 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); } }

Die HandleIncomingConnection -Methode wird zum Verarbeiten einer eingehenden Clientverbindung verwendet. Nach dem Akzeptieren einer Verbindung erhält es einen Stream für den Datenaustausch mit dem Client und initiiert einen asynchronen Vorgang, um Daten vom Client zu empfangen.

Anschließend erstellt die Methode einen Puffer zum Empfangen von Daten, basierend auf der vom verbundenen Client empfangenen Puffergröße. Ein asynchroner Vorgang wird gestartet, um mithilfe des erstellten Puffers Daten aus dem Stream zu lesen. Nach Abschluss des Lesevorgangs werden die Daten zur weiteren Verarbeitung an die Methode ReceiveData übergeben.

Außerdem startet die Methode einen weiteren asynchronen Vorgang, um eingehende Verbindungen zu akzeptieren, damit der nächste Client akzeptiert werden kann.

Wenn ein Client eine Verbindung zum Server herstellt, wird diese Methode aufgerufen, um die Verbindung zu verarbeiten, und der Server ist bereit, die nächsten Clients asynchron zu akzeptieren.

 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); }

Die Methode ReceiveData dient zur Verarbeitung der vom Client empfangenen Daten. Nachdem der Datenlesevorgang abgeschlossen ist, überprüft die Methode die Anzahl der gelesenen Bytes. Wenn die Anzahl der Bytes kleiner oder gleich Null ist, bedeutet dies, dass der Client die Verbindung getrennt hat. In diesem Fall schließt die Methode die Verbindung mit dem Client und beendet die Ausführung.

Wenn die Anzahl der gelesenen Bytes größer als Null ist, erstellt die Methode ein Byte-Array für die empfangenen Daten und kopiert die gelesenen Daten in dieses Array. Anschließend wandelt die Methode die empfangenen Bytes mithilfe der UTF-8-Kodierung in einen String um und gibt die empfangene Nachricht an die Konsole aus.

 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); }

Die SendData Methode wird zum Senden von Daten an den Client verwendet. Es wandelt die Nachrichtenzeichenfolge mithilfe der UTF-8-Kodierung in ein Byte-Array um und schreibt dieses Array in den Netzwerk-Stream. Nach dem Senden der Daten löscht die Methode den Stream und gibt die gesendete Nachricht an die Konsole aus.

Obwohl Zuverlässigkeit wie ein großes Plus klingt, kann diese TCP-Funktion bei Echtzeit-Multiplayer-Spielen zu Problemen führen. Die Datenübertragung in TCP kann durch den Mechanismus der Neuübertragung und Flusskontrolle verlangsamt werden, was zu Verzögerungen oder „Lags“ führen kann.

Benutzer-Datagramm-Protokoll

UDP ist ein einfacheres Protokoll, das keine Zustellung oder Paketreihenfolge garantiert. Dadurch ist es viel schneller als TCP, da es keine Zeit für den Verbindungsaufbau oder die erneute Übertragung verlorener Pakete aufwendet. Aufgrund seiner Geschwindigkeit und Einfachheit wird UDP häufig in Netzwerkspielen und anderen Anwendungen verwendet, die eine Echtzeit-Datenübertragung erfordern.

Allerdings erfordert die Verwendung von UDP, dass Entwickler die Datenübertragung sorgfältiger verwalten müssen. Da UDP die Zustellung nicht garantiert, müssen Sie möglicherweise eigene Mechanismen implementieren, um mit verlorenen oder nicht in der richtigen Reihenfolge angekommenen Paketen umzugehen.

UDP-Client

Dieser Code demonstriert eine grundlegende Implementierung eines UDP-Clients in Unity. Die StartUDPClient Methode initialisiert den UDP-Client und verbindet ihn mit dem durch die IP-Adresse und den Port angegebenen Remote-Server. Der Client beginnt mit dem asynchronen Empfang von Daten mithilfe der BeginReceive Methode und sendet mithilfe der SendData Methode eine Nachricht an den Server.

 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); } }

Wenn Daten vom Server empfangen werden, wird die Methode ReceiveData aufgerufen, die die empfangenen Bytes verarbeitet und in einen String umwandelt. Die empfangene Nachricht wird dann in der Konsole protokolliert. Der Client empfängt weiterhin Daten asynchron, indem er BeginReceive erneut aufruft.

Die SendData Methode wandelt die Nachricht in Bytes um und sendet sie mithilfe der Send Methode des UDP-Clients an den Server.

UDP-Server

Dieser Code demonstriert eine grundlegende Implementierung eines UDP-Servers in Unity. Die StartUDPServer -Methode initialisiert den UDP-Server am angegebenen Port und beginnt mit dem asynchronen Empfang von Daten mithilfe der BeginReceive -Methode.

Wenn Daten von einem Client empfangen werden, wird die Methode ReceiveData aufgerufen, die die empfangenen Bytes verarbeitet und in einen String umwandelt. Die empfangene Nachricht wird dann in der Konsole protokolliert. Der Server empfängt weiterhin Daten asynchron, indem er BeginReceive erneut aufruft.

 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); } }

Die SendData Methode akzeptiert eine Nachricht und einen IPEndPoint , der die Adresse und den Port des Clients darstellt. Es wandelt die Nachricht in Bytes um und sendet sie mithilfe der Send Methode des UDP-Servers an den Client.

Im Rahmen der Spieleentwicklung hängt die Wahl zwischen TCP und UDP weitgehend von der Art Ihres Spiels ab. Wenn Ihr Spiel eine zuverlässige Datenbereitstellung erfordert und die Reaktionszeit kein entscheidender Faktor ist (z. B. bei Echtzeitstrategie- oder rundenbasierten Spielen), ist TCP möglicherweise die geeignete Wahl. Wenn Ihr Spiel hingegen eine schnelle Datenübertragung erfordert und einen gewissen Datenverlust verkraften kann (z. B. bei Ego-Shootern oder Rennspielen), ist UDP möglicherweise die beste Wahl.

WebSocket

WebSocket ist ein Kommunikationsprotokoll, das den Aufbau einer dauerhaften Verbindung zwischen einem Browser und einem Server ermöglicht. Der Hauptunterschied zum regulären HTTP besteht darin, dass es eine bidirektionale Kommunikation ermöglicht. Der Server ist nicht nur in der Lage, auf Client-Anfragen zu antworten, sondern kann ihm auch Nachrichten senden.

WebSocket ist ein Protokoll auf Anwendungsebene, das auf TCP basiert. Es unterstützt Nachrichten, keine Streams, was es vom regulären TCP unterscheidet. WebSocket enthält zusätzliche Funktionen, die zu einem gewissen Leistungsaufwand führen können.

So funktioniert es Schritt für Schritt:

• Der Client sendet eine spezielle HTTP-Anfrage namens „Upgrade-Anfrage“. Diese Anfrage informiert den Server darüber, dass der Client zu WebSocket wechseln möchte.

  
  

• Wenn der Server WebSocket unterstützt und dem Wechsel zustimmt, antwortet er mit einer speziellen HTTP-Antwort, die das Upgrade auf WebSocket bestätigt.

  
  

• Nach dem Austausch dieser Nachrichten wird eine dauerhafte, bidirektionale Verbindung zwischen dem Client und dem Server aufgebaut. Beide Seiten können jederzeit Nachrichten senden, nicht nur als Reaktion auf Anfragen der anderen Seite.

  
  

• Jetzt können Client und Server jederzeit Nachrichten senden und empfangen. Jede WebSocket-Nachricht ist in „Frames“ verpackt, die angeben, wann die Nachricht beginnt und endet. Dadurch können Browser und Server Nachrichten korrekt interpretieren, selbst wenn sie in gemischter Reihenfolge eintreffen oder aufgrund von Netzwerkproblemen in Teile aufgeteilt sind.

Beide Seiten können die Verbindung jederzeit schließen, indem sie einen speziellen „Verbindung schließen“-Frame senden. Die Gegenseite kann mit einer Bestätigung der Schließung reagieren, danach müssen beide Seiten die Übermittlung weiterer Daten sofort einstellen. Statuscodes können auch verwendet werden, um den Grund für die Schließung anzugeben.

WebSocket-Client

Der folgende Code stellt ein Beispiel für die Implementierung eines WebSocket-Clients in Unity unter Verwendung der C#-Sprache und der WebSocketSharp- Bibliothek dar.

In der Methode Start() , die bei der Objektinitialisierung aufgerufen wird, wird eine neue Instanz von WebSocket erstellt und mit der Adresse Ihres WebSocket-Servers initialisiert.

Anschließend werden die Eventhandler OnOpen und OnMessage eingerichtet.

 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); } }

OnOpen wird ausgelöst, wenn eine Verbindung mit dem Server hergestellt wird. In diesem Beispiel wird beim Verbindungsaufbau eine Nachricht mit dem Text „Player1“ an den Server gesendet.

OnMessage wird ausgelöst, wenn eine Nachricht vom Server empfangen wird. Hier wird beim Empfang einer Nachricht deren Inhalt in der Konsole angezeigt.

Anschließend wird die ConnectAsync() -Methode aufgerufen, die asynchron eine Verbindung zum Server herstellt.

WebSocket-Server

Der folgende Code ist ein Beispiel für die Erstellung eines WebSocket-Servers.

In der Start() Methode, die bei der Initialisierung des Objekts aufgerufen wird, wird eine neue Instanz von WebSocketServer erstellt und mit der Adresse Ihres WebSocket-Servers initialisiert. Anschließend wird der AuthBehaviour WebSocket-Dienst zum Server hinzugefügt, der im Pfad /Auth verfügbar ist. Anschließend wird der Server mit der Methode Start() gestartet.

 using UnityEngine; using WebSocketSharp; using WebSocketSharp.Server; public class WebSocketServer : MonoBehaviour { void Start() { var socket = new WebSocketServer("ws://your-websocket-server-url"); socket.AddWebSocketService<AuthBehaviour>("/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); } }

AuthBehaviour ist eine von WebSocketBehavior abgeleitete Klasse, die das Serververhalten beim Empfang von Nachrichten von Clients definiert. Dabei wird die Methode OnMessage() überschrieben, die aufgerufen wird, wenn der Server eine Nachricht von einem Client empfängt.

Bei dieser Methode wird zunächst der Nachrichtentext extrahiert und dann eine Nachricht an die Konsole ausgegeben, die angibt, welcher Client eine Verbindung hergestellt hat, und zwar unter Verwendung des in der Nachricht übergebenen Namens. Anschließend sendet der Server eine Nachricht mit Informationen über den Abschluss der Authentifizierung an den Client zurück.

Abschluss

Wir haben besprochen, wie man Verbindungen für Unity-Spiele mithilfe von TCP, UDP und WebSockets erstellt und welche Vor- und Nachteile diese haben. Trotz der Leichtigkeit von UDP und der Zuverlässigkeit von TCP ist keines von beiden eine gute Wahl für die Organisation von Echtzeit-Multiplayer in Spielen. Bei UDP gehen einige Daten verloren und TCP bietet nicht die erforderliche Übertragungsgeschwindigkeit. Im nächsten Artikel besprechen wir, wie man eine zuverlässige Datenübertragung mithilfe von UDP organisiert.