Hinzufügen von Echtzeitfunktionen in der Unreal Engine 5.3 mit PubNub
Published: 2024-03-08 07:32:09

Wenn Sie Ihr Unreal Engine (UE) 5.3 Multiplayer- oder [Online-Spiel](https://www.pubnub.com/solutions/gaming/) um Echtzeitfunktionen erweitern möchten, sind Sie hier genau richtig. PubNub sorgt für Nachrichtenübermittlung mit niedriger Latenz und Skalierbarkeit und verbessert das Spielerlebnis mit sozialen Funktionen wie In-Game-Chat, Online-Statuserkennung, Freundeslisten, Punktesystemen und Bestenlisten und vielem mehr - alles in Echtzeit. Ganz gleich, ob Sie für Windows, Mac, iOS, Android, Virtual-Reality-Systeme wie Oculus und Meta Quest oder plattformübergreifend entwickeln, wir kümmern uns um die Infrastrukturebene Ihres Spiels für Echtzeit-Interaktivität, damit Sie sich auf Ihre Anwendung konzentrieren können.

Lesen Sie weiter, um zu erfahren, wie Sie das [Unreal-Engine-Modul](https://github.com/pubnub/c-core/tree/master/unreal) von PubNub nutzen können, um diese und weitere Echtzeitfunktionen in Ihr eigenes UE-Spiel zu implementieren.

Bitte denken Sie daran, dass sich unser Unreal Engine Plugin noch in einem frühen Entwicklungsstadium befindet. Wir freuen uns daher über jedes Feedback, das Sie uns an [devrel@pubnub.com](mailto:devrel@pubnub.com) oder über einen Pull Request/Issue in unserem [GitHub Repository](https://www.pubnub.com/how-to/admin-portal-presence/) senden.

Voraussetzungen
---------------

Bevor wir loslegen, müssen Sie einige Dinge vorbereiten:

1.  [Unreal Engine](https://www.unrealengine.com/en-US/unreal-engine-5): Stellen Sie sicher, dass Sie die Unreal Engine installiert haben. Dieser Beitrag wurde mit UE 5.3 erstellt.
    
2.  [IDE](https://docs.unrealengine.com/5.3/en-US/setting-up-visual-studio-development-environment-for-cplusplus-projects-in-unreal-engine/): Es wird empfohlen, Visual Studios mit UE zu verwenden. Befolgen Sie unbedingt die Anweisungen von Epic Games zur Einrichtung von UE 5.3 mit Visual Studios.
    
3.  [PubNub](https://www.pubnub.com/): Melden Sie sich für ein kostenloses [PubNub-Konto](https://admin.pubnub.com/#/login) an, um Ihre API-Schlüssel zu erhalten, die für die Verbindung mit dem Netzwerk erforderlich sind. Sie müssen Ihre App und Ihr Keyset erstellen; wie das geht, erfahren Sie in dieser [Anleitung](https://www.pubnub.com/how-to/admin-portal-create-keys/). Außerdem müssen Sie die Präsenz für die Online-Erkennung aktivieren. Wie das geht, erfahren Sie in unserem [Leitfaden](https://www.pubnub.com/how-to/admin-portal-presence/).
    

Integrieren Sie das PubNub Unreal Modul
---------------------------------------

Um das PubNub Unreal Engine Modul für die Online-Funktionen nutzen zu können, müssen Sie das SDK einrichten und zu Ihrem Projekt hinzufügen, damit Sie die Funktionen integrieren können.

### SDK-Einrichtung

Klonen Sie zunächst das SDK-Repository in den Quellcode Ihres Unreal Engine-Projekts:

```js
git clone [Repository_URL] [Your_Unreal_Project]/Source/ThirdParty/
```

Ersetzen Sie `[Repository_URL]` durch die tatsächliche URL des PubNub C-Core SDK Repository. Wenn der ThirdParty-Ordner nicht existiert, erstellen Sie ihn.

Wenn Sie unter Windows arbeiten, öffnen Sie das Projekt in Visual Studios. Sie benötigen Zugriff auf Tools > Command Line > Developer Command Prompt, um den Befehl `nmake` auszuführen.

Navigieren Sie zum SDK-Verzeichnis und kompilieren Sie mit dem entsprechenden Befehl für Ihr System (Hinweis: Dieser Blog wurde mit einem Windows-Betriebssystem geschrieben und verwendet den Windows-Befehl):

POSIX (Linux/Mac)

Ersetzen Sie Option, Architektur und Implementierung entsprechend.

```js
make -C <option> -f <architecture>.mk pubnub_<implementation>.a
```

Windows:

```js
nmake -f windows.mk
```

Windows Universal-Plattform:

```js
nmake -f windows/uwp.mk
```

OpenSSL:

```js
make -C openssl -f posix.mk pubnub_sync.a
```

**Hinweis**: Wenn Sie die OpenSSL-Option verwenden, stellen Sie sicher, dass Ihre OpenSSL-Bibliotheksheader mit denen von Unreal übereinstimmen.

Öffnen Sie /Source/ThirdParty/PubNubModule/PubNubModule.Build.cs und passen Sie die Optionen `Option`, `Architektur` und `Implementierung` mit denselben Werten an, die Sie beim Kompilieren verwendet haben. Zum Beispiel:

```js
private readonly string Option = "windows"; // posix, windows, openssl
private readonly string Architecture = "windows"; // posix, windows
private readonly string Implementation = "callback"; // sync, callback
```

Importieren Sie das Modul, indem Sie die Projektzieldateien so ändern, dass sie das PubNub-Modul enthalten. Stellen Sie sicher, dass Sie `UnrealProject` durch Ihren tatsächlichen Projektnamen ersetzen:

```js
public class <UnrealProject>[Editor]Target : TargetRules
{
    public <UnrealProject>[Editor]Target (TargetInfo Target) : base(Target)
    {
        //...
        ExtraModuleNames.Add("PubNubModule");
    }
}
```

In `UnrealProject.uproject`:

```js
{
  //...
  "Modules": [
    //...
    {
      "Name": "PubNubModule",
      "Type": "Runtime",
      "LoadingPhase": "Default"
    }
  ],
  //...
}
```

Sie sind mit der Einrichtung des SDK fast fertig - jetzt müssen Sie nur noch die Visual Studios Project-Dateien generieren (oder die Dateien aktualisieren, um die neuen Änderungen aufzunehmen). Dazu gibt es mehrere Möglichkeiten, z. B. über den Unreal Engine 5.3-Editor oder durch Rechtsklick auf die `.uproject-Datei` im Datei-Explorer und Generierung der Visual Studio-Projektdateien:

![](https://www.pubnub.com/cdn/3prze68gbwl1/2g0GKBvbfZQ1h0a519wSit/983281f98f33410e0f8a33eb81d1b86a/2023-10-15_11_10_40-UnrealEngine-GeneratedBuildFiles.png)

### Verwendung des Moduls

Um das PubNub Unreal Engine Modul zu verwenden, müssen Sie die Datei `Module.Build.cs` in dem Modul, in dem Sie PubNub verwenden möchten, ändern und das Modul hinzufügen. Ersetzen Sie dabei `Module` durch den Namen Ihres Moduls:

```js
public class <Module> : ModuleRules
{
    public <Module>(ReadOnlyTargetRules Target) : base(Target)
    {
        //...
        PrivateDependencyModuleNames.Add("PubNubModule");
    }
}
```

Schließlich müssen Sie den PubNub-Header über `#include "PubNub.h"` in Ihre Dateien aufnehmen. Sie müssen die Includes `THIRD_PARTY_INCLUDES_START` und `THIRD_PARTY_INCLUDES_END` nicht einschließen, da dies bereits erledigt ist.

Echtzeit-Funktionen implementieren
----------------------------------

Jetzt können Sie damit beginnen, diese Echtzeit-Anwendungsfälle in Ihr UE-Spiel zu implementieren! Aber zuerst wollen wir ein wenig tiefer eintauchen und verstehen, wie PubNub auf hohem Niveau funktioniert.

### PubNub Überblick

PubNub basiert auf dem Pub/Sub (Publish/Subscribe) Modell. Ein Benutzer [veröffentlicht](https://www.pubnub.com/docs/general/messages/publish) eine Nachricht, die im Wesentlichen eine Nutzlast ist, die alle relevanten Informationen enthält, im PubNub-Netzwerk. Benutzer, die die Nachricht und andere generierte Ereignisse empfangen oder anhören wollen, [abonnieren](https://www.pubnub.com/docs/general/messages/receive) das PubNub-Netzwerk und analysieren die Nachricht. [Ereignis-Listener](https://www.pubnub.com/docs/general/messages/receive#add-a-listener) werden verwendet, um Nachrichten und Ereignisse, die im PubNub-Netzwerk generiert werden, abzufangen und basierend auf einer stattgefundenen Aktion auszulösen.

Um sicherzustellen, dass die Nachricht an die richtigen Empfänger gelangt, werden [Kanäle](https://www.pubnub.com/docs/general/channels/overview) als Mechanismus verwendet, über den die Daten von einem Gerät zum anderen übertragen werden. Kanäle werden jedes Mal benötigt, wenn ein Gerät im PubNub-Netzwerk veröffentlichen und abonnieren möchte. Während ein Benutzer immer nur eine Nachricht veröffentlichen kann, kann ein Benutzer viele verschiedene Kanäle gleichzeitig abonnieren.

### In-Game-Chat

In-Game-Chat oder In-App-Messaging erhöht das Engagement der Spieler und fördert die Benutzerbindung. Der spielinterne Chat ermöglicht es den Spielern, miteinander zu kommunizieren, fördert das Gemeinschaftsgefühl und bietet eine Plattform für soziale Interaktion, die das Spielerlebnis angenehmer macht.

Sie können Ihrem UE 5-Videospiel einen In-Game-Chat für die Echtzeitkommunikation hinzufügen, indem Sie die Pub/Sub-Architektur von PubNub nutzen und Nachrichten [veröffentlichen](https://www.pubnub.com/docs/sdks/c-core/api-reference/publish-and-subscribe#publish), sobald ein Spieler eine Nachricht sendet. Die Clients müssen sich bei den entsprechenden Kanälen [anmelden](https://www.pubnub.com/docs/sdks/c-core/api-reference/publish-and-subscribe#subscribe), um auf diese Nachrichten zu warten (wobei die Art des Chats durch den [Namen](https://www.pubnub.com/docs/general/channels/channel-naming) des [Kanals](https://www.pubnub.com/docs/general/channels/channel-naming) bestimmt wird), sie in einem `OnMessageReceived-Ereignis-Listener` abzufangen und entsprechend zu behandeln:

```js
// Initialize the PubNub client
PubNubClient->Init(YourPublishKey, YourSubscribeKey);

// Sending a message
FString Channel = "all-chat";
FString Message = "Hello, fellow friends!";
PubNubClient->Publish(Channel, Message);

// Receiving messages:
PubNubClient->Subscribe(Channel);
PubNubClient->OnMessageReceived.AddLambda([](const FString& Channel, const FString& Message) {
    // Handle the received message here and display on screen.
    UE_LOG(LogTemp, Warning, TEXT("Received message on %s: %s"), *Channel, *Message);
});
```

### Online-Status-Erkennung

[Präsenz](https://www.pubnub.com/docs/general/presence/overview) wird verwendet, um den Online-Status der Spieler in Ihrem Spiel zu ermitteln und Ereignisse zu erzeugen, die Informationen über ihren Status in Echtzeit liefern. Präsenz ist eine unglaublich wichtige Funktion für Ihr Spiel, da sie Ihre Spieler über den Online-Status ihrer Freunde informiert, ob sie online/offline sind, sich gerade in einem Match oder einer Lobby befinden, wo sie sich in der Spielwelt befinden und sogar welche Aktivität sie gerade ausüben.

Mit der [Präsenz-API](https://www.pubnub.com/docs/sdks/c-core/api-reference/presence) können Sie verfolgen, wann Benutzer online kommen und gehen, einschließlich benutzerdefinierter Ereignisse mit dem [Benutzerstatus](https://www.pubnub.com/docs/sdks/c-core/api-reference/presence#user-state). Sie würden dann jeden Client auf einen Kanal abonnieren, um die Anwesenheit zu verfolgen und auf diese Ereignisse über den Ereignis-Listener `OnPresenceEventReceived` zu hören:

```js
// Subscribe to a presence channel
FString PresenceChannel = "presence.all";
PubNubClient->Subscribe(PresenceChannel);

// Listen for presence events
PubNubClient->OnPresenceEventReceived.AddLambda([](const FPubNubPresenceEvent& Event) {
    if (Event.Action == EPubNubPresenceAction::Join) {
        UE_LOG(LogTemp, Warning, TEXT("%s joined the game!"), *Event.UUID);
    } else if (Event.Action == EPubNubPresenceAction::Leave) {
        UE_LOG(LogTemp, Warning, TEXT("%s left the game."), *Event.UUID);
    }
    // Handle other presence actions as needed, including custom user state.
});
```

### Freundes-/Gilden-/Bündnis-/Clan-Listen

Die Integration von Freundes-, Gilden-, Allianz- und Clan-Listen in Ihr Unreal-Engine-Spiel ist ein wichtiger Aspekt zur Förderung der Spielerbindung. Sie ermöglichen es Ihren Spielern, eine engere Verbindung zu anderen Spielern im Spiel aufzubauen, unabhängig davon, ob sie außerhalb des Spiels befreundet sind oder ob sie während eines intensiven Matches eine enge Bindung eingegangen sind.

Diese Listen können in Ihr Spiel implementiert werden, indem Sie Channel-Gruppen erstellen und diese abonnieren. Mithilfe von [Kanalgruppen](https://www.pubnub.com/docs/general/channels/subscribe#channel-groups) können Sie eine große, dauerhafte Anzahl von Kanälen auf einmal verwalten. Kanalgruppen sind im Wesentlichen ein Verweis auf eine Liste von Kanälen, die es Ihnen ermöglichen, einen einzigen Abonnement-Aufruf für bis zu 2000 Kanäle pro Kanalgruppe zu senden. Kanalgruppen sind für die Benutzer-ID, die mit dem Netzwerk verbunden ist, eindeutig, d. h. Sie können eine Kanalgruppe eindeutig benennen und an diesen Spieler binden.

Sie können Freundes-/Gilden-/Bündnis-/Clan-Listen hinzufügen, indem Sie die [Kanalgruppen-API](https://www.pubnub.com/docs/sdks/c-core/api-reference/channel-groups) verwenden, um jede Liste mit einem eindeutigen Namen zu definieren, wobei das Hinzufügen und Entfernen von Kanälen zu jeder Liste bedeutet, dass die entsprechenden Spieler im Spiel zu den Listen hinzugefügt bzw. aus ihnen entfernt werden. Sowohl die Erkennung des Online-Status als auch der Chat für diese Gruppen würden den vorherigen Abschnitten für den Chat im Spiel und die Erkennung des Online-Status mit Präsenz folgen. Weitere Details zur Implementierung von Freundes-/Gilden-/Bündnis-/Clan-Listen finden Sie in unserer [Dokumentation](https://www.pubnub.com/docs/general/resources/design-pattern-friend-list-status-feeds) zur Einrichtung der Architektur.

### Live-Ranglisten und Wertungssysteme

Wertungssysteme und Bestenlisten sind wichtige Aspekte für ein unterhaltsames Spielerlebnis. Wertungssysteme liefern wichtige Informationen, während die Spieler in einem intensiven Match engagiert sind, und sind notwendig, um die besten Gewinnchancen zu bestimmen, während Ranglisten dazu dienen, den Wettbewerb unter den Spielern zu fördern, um die Highscores nach Matches zu sehen. Beides fördert die Wiederholbarkeit des Spiels und ist eine einfache Möglichkeit, die Spielerbindung zu erhöhen.

Wertungssysteme können ähnlich wie Nachrichten im Spiel implementiert werden: Richten Sie ein Kanalmuster ein, damit nur die Spieler, die am Spiel teilnehmen, die Aktualisierungen erhalten, und abonnieren Sie diesen Kanal, wenn die betreffenden Spieler dem Spiel beitreten. Sobald es Aktualisierungen zu senden gibt, z. B. wenn neue Schadensaktualisierungen auftreten, veröffentlichen Sie die Aktualisierung, indem Sie eine Nachricht erstellen und diese senden. In unserem [Leitfaden für Wertungssysteme](https://www.pubnub.com/how-to/develop-game-scoring-system/) finden Sie Informationen zu den verschiedenen Arten von Anzeigetafeln, die Sie für Ihr Unreal Engine-Projekt implementieren können.

Sobald ein Spiel beendet ist, wird ein letzter Aufruf gemacht, um die globalen Bestenlisten zu aktualisieren, die andere Spieler sehen können. Durch die Verwendung von [Funktionen](https://www.pubnub.com/products/functions/) können Sie Geschäftslogik auf dem Edge erstellen und ausführen, um Echtzeitnachrichten zu routen, zu filtern, zu transformieren, zu erweitern und zu aggregieren, während sie durch das PubNub-Netzwerk geleitet werden. Das bedeutet, dass Sie Ihren eigenen Code oder [Integrationen von Drittanbietern](https://www.pubnub.com/integrations/) hosten können, ohne Ihren Server hochfahren zu müssen, um PubNub-Nachrichten abzufangen, bevor oder nachdem sie auftreten. Außerdem können Sie relevante Informationen mit dem [KV-Store-Modul](https://www.pubnub.com/docs/sdks/functions/kvstore-module) speichern, einem persistenten Key-Value-Store, der als Datenbank für Ihre Funktionen fungiert.

Für Bestenlisten möchten Sie die Spielstände aktualisieren, nachdem die Spieler ein Spiel beendet haben, und dann die Spieler über die aktualisierte Bestenliste benachrichtigen, indem Sie einen Kanal abonnieren, der für die Aktualisierung der Bestenliste bestimmt ist. Wenn Sie mehr über Funktionen erfahren möchten, lesen Sie bitte unsere [Dokumentation](https://www.pubnub.com/docs/general/serverless/functions/overview).

Was kommt als Nächstes?
-----------------------

In diesem Beitrag haben Sie gelernt, wie Sie Ihrem Unreal Engine 5.3-Spiel mit PubNub Echtzeitfunktionen hinzufügen können. Ganz gleich, ob Sie [In-Game-Messaging, Live-Scoring-Systeme und Leaderboards](https://www.pubnub.com/solutions/gaming/) oder sogar Freundes-/Gilden-/Bündnis-/Clan-Listen hinzufügen möchten, Spieleentwickler können sich auf PubNub verlassen, um diese Funktionen in Echtzeit zu nutzen.

Wenn Sie Ihr eigenes UE 5.3-Spiel mit unserem [Unreal-Engine-Modul](https://github.com/pubnub/c-core/tree/master/unreal) um Echtzeit-Features erweitern möchten, sollten Sie sich die [Dokumentation](https://www.pubnub.com/docs/sdks/c-core) ansehen, um zu erfahren, was Sie für die erfolgreiche Implementierung dieser Echtzeit-Features benötigen. Wir haben auch SDKs für andere Spiele-Engines, wie z.B. unsere [Unity](https://www.pubnub.com/docs/sdks/unity) , die in unserem [Unity-Spiel](https://github.com/PubNubDevelopers/unity-multiplayer-shooter) verwendet wird, um die in diesem Beitrag besprochenen Funktionen und mehr zu präsentieren. Und denken Sie daran, dass sich unser Unreal Engine Plugin noch in einem frühen Entwicklungsstadium befindet. Wir freuen uns daher über jedes Feedback und jede Frage, die Sie an [devrel@pubnub.com](mailto:devrel@pubnub.com) oder über einen Pull Request/Issue in unserem [GitHub Repository](https://www.pubnub.com/how-to/admin-portal-presence/) senden.

#### Inhalt

[VoraussetzungenIntegration](#h-0)[des PubNub](#h-1)[Unreal-ModulsSDK-SetupVerwendung](#h-2)[des ModulsImplementierung von](#h-3)[Echtzeit-FeaturesPubNub-ÜbersichtIn-Game-ChatOnline-Status-ErkennungFreunde/Gilde/Allianz/Clan-ListenLive-Leaderboards und PunktesystemeWas](#h-9)[kommt als nächstes](#h-10)

Wie kann PubNub Ihnen helfen?
=============================

Dieser Artikel wurde ursprünglich auf [PubNub.com](https://www.pubnub.com/blog/add-real-time-features-in-unreal-engine-5-3-with-pubnub/) veröffentlicht.

Unsere Plattform hilft Entwicklern bei der Erstellung, Bereitstellung und Verwaltung von Echtzeit-Interaktivität für Webanwendungen, mobile Anwendungen und IoT-Geräte.

Die Grundlage unserer Plattform ist das größte und am besten skalierbare Echtzeit-Edge-Messaging-Netzwerk der Branche. Mit über 15 Points-of-Presence weltweit, die 800 Millionen monatlich aktive Nutzer unterstützen, und einer Zuverlässigkeit von 99,999 % müssen Sie sich keine Sorgen über Ausfälle, Gleichzeitigkeitsgrenzen oder Latenzprobleme aufgrund von Verkehrsspitzen machen.

PubNub erleben
--------------

Sehen Sie sich die [Live Tour](https://www.pubnub.com/tour/introduction/) an, um in weniger als 5 Minuten die grundlegenden Konzepte hinter jeder PubNub-gestützten App zu verstehen

Einrichten
----------

Melden Sie sich für einen [PubNub-Account](https://admin.pubnub.com/signup/) an und erhalten Sie sofort kostenlosen Zugang zu den PubNub-Schlüsseln

Beginnen Sie
------------

Mit den [PubNub-Dokumenten](https://www.pubnub.com/docs) können Sie sofort loslegen, unabhängig von Ihrem Anwendungsfall oder [SDK](https://www.pubnub.com/docs)