Dodawanie funkcji czasu rzeczywistego w silniku Unreal Engine 5.3 za pomocą PubNub
Published: 2024-03-08 07:14:10

Jeśli chcesz dodać funkcje czasu rzeczywistego do gry wieloosobowej lub [sieciowej](https://www.pubnub.com/solutions/gaming/) w Unreal Engine (UE) 5.3, jesteś we właściwym miejscu. PubNub zapewnia niskie opóźnienia w przesyłaniu wiadomości i skalowalność, zwiększając wrażenia graczy dzięki funkcjom społecznościowym, takim jak czat w grze, wykrywanie statusu online, listy znajomych, systemy punktacji i tabele wyników oraz wiele innych, a wszystko to w czasie rzeczywistym. Niezależnie od tego, czy tworzysz gry dla systemów Windows, Mac, iOS, Android, systemów rzeczywistości wirtualnej, takich jak Oculus i Meta Quest, czy też korzystasz z różnych platform, dbamy o warstwę infrastruktury Twojej gry, aby zapewnić interaktywność w czasie rzeczywistym, dzięki czemu możesz skupić się na swojej aplikacji.

Czytaj dalej, aby dowiedzieć się, jak możesz wykorzystać [moduł Unreal Engine](https://github.com/pubnub/c-core/tree/master/unreal) firmy PubNub do zaimplementowania tych i innych funkcji czasu rzeczywistego we własnej grze UE.

Należy pamiętać, że nasza wtyczka Unreal Engine jest wciąż na wczesnym etapie rozwoju, więc będziemy wdzięczni za wszelkie opinie przesłane na adres [devrel@pubnub.com](mailto:devrel@pubnub.com) lub poprzez przesłanie żądania ściągnięcia/problemu do naszego [repozytorium GitHub](https://www.pubnub.com/how-to/admin-portal-presence/).

Wymagania wstępne
-----------------

Zanim zaczniemy, musisz przygotować kilka rzeczy:

1.  [Unreal Engine](https://www.unrealengine.com/en-US/unreal-engine-5): Upewnij się, że masz zainstalowany silnik Unreal Engine. Ten post został stworzony przy użyciu UE 5.3.
    
2.  [IDE](https://docs.unrealengine.com/5.3/en-US/setting-up-visual-studio-development-environment-for-cplusplus-projects-in-unreal-engine/): Zaleca się używanie Visual Studios z UE. Postępuj zgodnie z instrukcjami Epic Games dotyczącymi konfiguracji UE 5.3 z Visual Studios.
    
3.  [PubNub](https://www.pubnub.com/): Załóż bezpłatne konto [PubNub](https://admin.pubnub.com/#/login), aby uzyskać klucze API wymagane do połączenia z siecią. Będziesz musiał utworzyć swoją aplikację i zestaw kluczy; możesz dowiedzieć się, jak to zrobić, postępując zgodnie z tym [przewodnikiem](https://www.pubnub.com/how-to/admin-portal-create-keys/). Konieczne będzie również włączenie funkcji Presence w celu wykrywania online; jak to zrobić, dowiesz się z naszego [przewodnika](https://www.pubnub.com/how-to/admin-portal-presence/).
    

Integracja modułu PubNub Unreal Module
--------------------------------------

Aby móc korzystać z modułu PubNub Unreal Engine do zasilania funkcji online, należy przeprowadzić konfigurację SDK i dodać go do projektu, aby móc zintegrować funkcje.

### Konfiguracja SDK

Najpierw sklonuj repozytorium SDK do źródła projektu Unreal Engine:

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

Zastąp `[Repository_URL]` rzeczywistym adresem URL repozytorium PubNub C-Core SDK. Jeśli folder ThirdParty nie istnieje, utwórz go.

Jeśli korzystasz z systemu Windows, otwórz projekt w Visual Studios. Będziesz potrzebował dostępu do Narzędzia > Wiersz poleceń > Wiersz poleceń dewelopera, aby wykonać polecenie `nmake` .

Przejdź do katalogu SDK i skompiluj przy użyciu odpowiedniego polecenia dla swojego systemu (Uwaga: Ten blog został napisany przy użyciu systemu operacyjnego Windows i użyto polecenia Windows):

POSIX (Linux/Mac)

Zastąp odpowiednio opcję, architekturę i implementację.

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

Windows:

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

Windows Universal Platform:

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

OpenSSL:

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

**Uwaga**: Jeśli używasz opcji OpenSSL, upewnij się, że nagłówki biblioteki OpenSSL są zgodne z nagłówkami biblioteki Unreal.

Otwórz /Source/ThirdParty/PubNubModule/PubNubModule.Build.cs i dostosuj opcje `Option`, `Architecture` i `Implementation` z tymi samymi wartościami, których użyłeś do kompilacji. Na przykład:

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

Zaimportuj moduł, modyfikując pliki docelowe projektu, aby zawierały moduł PubNub. Pamiętaj, aby zastąpić `UnrealProject` rzeczywistą nazwą projektu:

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

W `UnrealProject.uproject`:

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

Konfiguracja SDK jest prawie zakończona - pozostaje tylko wygenerować pliki projektu Visual Studios (lub odświeżyć pliki, aby uwzględnić nowe zmiany). Można to zrobić na kilka sposobów, w tym za pomocą edytora Unreal Engine 5.3 lub klikając prawym przyciskiem myszy plik `.uproject` w eksploratorze plików i generując pliki projektu Visual Studio:

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

### Korzystanie z modułu

Aby rozpocząć korzystanie z modułu PubNub Unreal Engine, należy zmodyfikować plik `Module.Build.cs` w module, w którym ma być używany PubNub i dodać moduł. Pamiętaj, aby zastąpić `Module` nazwą swojego modułu:

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

Na koniec musisz dołączyć nagłówek PubNub do swoich plików poprzez `#include "PubNub.h"`. Nie będziesz musiał zawijać include `THIRD_PARTY_INCLUDES_START` i `THIRD_PARTY_INCLUDES_END` , ponieważ jest to już zrobione.

Wdrażanie funkcji czasu rzeczywistego
-------------------------------------

Jesteś teraz gotowy, aby rozpocząć wdrażanie tych przypadków użycia w czasie rzeczywistym w swojej grze UE Game! Najpierw jednak zagłębmy się nieco w zrozumienie działania PubNub na wysokim poziomie.

### Przegląd PubNub

PubNub opiera się na modelu Pub/Sub (publikuj/subskrybuj). Użytkownik [publikuje](https://www.pubnub.com/docs/general/messages/publish) wiadomość, która jest zasadniczo ładunkiem zawierającym wszystkie istotne informacje, w sieci PubNub. Użytkownicy, którzy chcą odebrać lub odsłuchać wiadomość i inne wygenerowane zdarzenia, [subskrybują](https://www.pubnub.com/docs/general/messages/receive) sieć PubNub i analizują wiadomość. [Odsłuchiwacze zdarzeń](https://www.pubnub.com/docs/general/messages/receive#add-a-listener) służą do przechwytywania wiadomości i zdarzeń generowanych w sieci PubNub i wyzwalania ich na podstawie podjętych działań.

Aby zapewnić, że wiadomość dotrze do właściwych odbiorców, [kanały](https://www.pubnub.com/docs/general/channels/overview) są wykorzystywane jako mechanizm, za pośrednictwem którego dane są przesyłane z jednego urządzenia do drugiego. Kanały są wymagane za każdym razem, gdy urządzenie chce publikować i subskrybować sieć PubNub. Podczas gdy użytkownik może opublikować tylko jedną wiadomość na raz, użytkownik może subskrybować wiele różnych kanałów na raz.

### Czat w grze

Czat w grze lub wiadomości w aplikacji zwiększają zaangażowanie graczy i pomagają im pozostać w grze. Czat w grze pozwala graczom komunikować się ze sobą, wspierając poczucie wspólnoty i zapewniając platformę do interakcji społecznych, która sprawia, że korzystanie z gry jest przyjemniejsze.

Możesz dodać czat w grze do swojej gry wideo UE 5 w celu komunikacji w czasie rzeczywistym, korzystając z architektury Pub/Sub PubNub, [publikując](https://www.pubnub.com/docs/sdks/c-core/api-reference/publish-and-subscribe#publish) wiadomości za każdym razem, gdy gracz wysyła wiadomość. Klienci musieliby [subskrybować](https://www.pubnub.com/docs/sdks/c-core/api-reference/publish-and-subscribe#subscribe) odpowiednie kanały, aby nasłuchiwać tych wiadomości (gdzie typ czatu jest określony przez [nazwę kanału](https://www.pubnub.com/docs/general/channels/channel-naming)), przechwytywać je w detektorze zdarzeń `OnMessageReceived` i odpowiednio obsługiwać:

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

### Wykrywanie statusu online

[Obecność](https://www.pubnub.com/docs/general/presence/overview) jest używana do określania statusu online graczy w grze, generując zdarzenia w celu dostarczenia informacji o ich statusie w czasie rzeczywistym. Obecność jest niezwykle ważną funkcją dla twojej gry, ponieważ pozwala graczom poznać status online ich znajomych, czy są online / offline, aktualnie w meczu lub lobby, ich lokalizację w świecie gry, a nawet w jaką aktywność są zaangażowani.

Korzystając z [Presence API](https://www.pubnub.com/docs/sdks/c-core/api-reference/presence), możesz śledzić, kiedy użytkownicy przychodzą i wychodzą online, w tym niestandardowe zdarzenia ze [stanem użytkownika](https://www.pubnub.com/docs/sdks/c-core/api-reference/presence#user-state). Następnie należy zasubskrybować każdego klienta do kanału, aby śledzić obecność i nasłuchiwać tych zdarzeń za pośrednictwem detektora `OnPresenceEventReceived` :

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

### Listy znajomych/gildii/sojuszu/klanu

Włączenie listy znajomych, gildii, sojuszy i klanów do gry Unreal Engine jest kluczowym aspektem promowania zaangażowania graczy. Pozwala to graczom na nawiązanie bliższych relacji z innymi graczami w grze, niezależnie od tego, czy są przyjaciółmi poza grą, czy też nawiązali bliską więź podczas intensywnego meczu.

Listy te można zaimplementować w grze, tworząc i subskrybując grupy kanałów. [Grupy](https://www.pubnub.com/docs/general/channels/subscribe#channel-groups) kanałów pozwalają zarządzać dużą, stałą liczbą kanałów jednocześnie. Grupy kanałów są zasadniczo wskaźnikiem do listy kanałów, które umożliwiają wysłanie pojedynczego wywołania subskrypcji dla maksymalnie 2000 kanałów na grupę kanałów. Grupy kanałów są unikalne dla identyfikatora użytkownika, który jest podłączony do sieci, co oznacza, że można nadać grupie kanałów unikalną nazwę i powiązać ją z danym graczem.

Listy znajomych/gildii/sojuszy/klanów można dodawać za pomocą interfejsu [API grup](https://www.pubnub.com/docs/sdks/c-core/api-reference/channel-groups) kanałów, aby zdefiniować każdą listę o unikalnej nazwie, gdzie dodawanie i usuwanie kanałów do każdej listy reprezentuje dodawanie/usuwanie odpowiednich graczy z list w grze. Zarówno wykrywanie statusu online, jak i czat dla tych grup byłyby zgodne z poprzednimi sekcjami dotyczącymi czatu w grze i wykrywania statusu online za pomocą Presence. Więcej szczegółów na temat implementacji list znajomych/gildii/sojuszu/klanu można znaleźć w naszej [dokumentacji](https://www.pubnub.com/docs/general/resources/design-pattern-friend-list-status-feeds) dotyczącej konfiguracji architektury.

### Tablice wyników na żywo i systemy punktacji

Systemy punktacji i tabele liderów są kluczowymi aspektami zapewniającymi przyjemną rozgrywkę. Systemy punktacji dostarczają istotnych informacji, gdy gracze są zaangażowani w intensywny mecz i są niezbędne do określenia najlepszej szansy na wygraną, podczas gdy tablice wyników są wykorzystywane jako sposób na zachęcenie graczy do rywalizacji w celu przeglądania najlepszych wyników po meczach. Oba zachęcają do powtarzalności i są łatwym sposobem na zwiększenie lojalności graczy.

Systemy punktacji można wdrożyć podobnie do wiadomości w grze: skonfiguruj wzorzec kanału, aby tylko ci, którzy są w meczu, otrzymywali aktualizacje i subskrybuj ten kanał, gdy odpowiedni gracze dołączą do meczu. Gdy pojawią się aktualizacje do wysłania, na przykład gdy pojawią się nowe aktualizacje obrażeń, opublikuj aktualizację, tworząc wiadomość i wysyłając ją. Zapoznaj się z naszym [przewodnikiem po systemach punktacji](https://www.pubnub.com/how-to/develop-game-scoring-system/) na temat różnych typów tablic wyników, które możesz zaimplementować w swoim projekcie Unreal Engine.

Po zakończeniu meczu wykonywane jest ostatnie połączenie w celu zaktualizowania globalnych tabel wyników dla innych graczy. Korzystając z [Functions](https://www.pubnub.com/products/functions/), można tworzyć i wykonywać logikę biznesową na krawędzi, aby kierować, filtrować, przekształcać, rozszerzać i agregować wiadomości w czasie rzeczywistym, gdy przechodzą one przez sieć PubNub. Oznacza to, że można hostować własny kod lub [integracje innych firm](https://www.pubnub.com/integrations/) bez uruchamiania serwera w celu przechwytywania komunikatów PubNub przed lub po ich wystąpieniu, a także przechowywać odpowiednie informacje za pomocą [modułu KV store](https://www.pubnub.com/docs/sdks/functions/kvstore-module), który jest trwałym magazynem klucz-wartość, który działa jak baza danych dla funkcji.

W przypadku tabel liderów, chcesz zaktualizować wyniki po zakończeniu meczu przez graczy, a następnie powiadomić graczy o zaktualizowanej tabeli liderów, subskrybując kanał poświęcony aktualizacjom tabeli liderów. Możesz dowiedzieć się więcej o funkcjach, zagłębiając się w naszą [dokumentację](https://www.pubnub.com/docs/general/serverless/functions/overview).

Co dalej
--------

W tym poście dowiedziałeś się, jak dodać funkcje czasu rzeczywistego do gry Unreal Engine 5.3 za pomocą PubNub. Niezależnie od tego, czy chcesz dodać [wiadomości w grze, systemy punktacji na żywo i tabele wyników](https://www.pubnub.com/solutions/gaming/), czy nawet listy znajomych/gildii/sojuszu/klanu, twórcy gier mogą polegać na PubNub, aby zasilać te funkcje w czasie rzeczywistym.

Jeśli chcesz rozpocząć dodawanie funkcji czasu rzeczywistego do własnej gry UE 5.3 za pomocą naszego [modułu Unreal Engine](https://github.com/pubnub/c-core/tree/master/unreal), zapoznaj się z [dokumentacją](https://www.pubnub.com/docs/sdks/c-core) , aby dowiedzieć się, czego potrzebujesz, aby pomyślnie wdrożyć te funkcje w czasie rzeczywistym. Posiadamy również pakiety SDK dla innych silników gier, takich jak [Unity](https://www.pubnub.com/docs/sdks/unity) , który jest używany w naszej [grze Unity](https://github.com/PubNubDevelopers/unity-multiplayer-shooter), aby zaprezentować funkcje omówione w tym poście i nie tylko. I pamiętaj, że nasza wtyczka Unreal Engine jest wciąż na wczesnym etapie rozwoju, więc będziemy wdzięczni za wszelkie opinie lub pytania przesłane na adres [devrel@pubnub.com](mailto:devrel@pubnub.com) lub poprzez przesłanie żądania ściągnięcia/problemu do naszego [repozytorium GitHub](https://www.pubnub.com/how-to/admin-portal-presence/).

#### Zawartość

[Wymagania wstępneIntegracja](#h-0)[modułu Unreal](#h-1)[PubNubKonfiguracja SDKUżywanie](#h-2)[modułuWdrażanie](#h-3)[funkcji czasu](#h-4)[rzeczywistegoPrzegląd](#h-5)[](#h-4)[PubNubCzat](#h-6)[w](#h-5)[grzeWykrywanie statusu](#h-7)[onlineListy](#h-8)[znajomych/gildii/sojuszu/planuTablice wyników na żywo i systemy punktacjiCo](#h-9)[dalej](#h-10)?

Jak PubNub może ci pomóc?
=========================

Ten artykuł został pierwotnie opublikowany na [PubNub.com](https://www.pubnub.com/blog/add-real-time-features-in-unreal-engine-5-3-with-pubnub/)

Nasza platforma pomaga programistom tworzyć, dostarczać i zarządzać interaktywnością w czasie rzeczywistym dla aplikacji internetowych, aplikacji mobilnych i urządzeń IoT.

Fundamentem naszej platformy jest największa w branży i najbardziej skalowalna sieć przesyłania wiadomości w czasie rzeczywistym. Dzięki ponad 15 punktom obecności na całym świecie obsługującym 800 milionów aktywnych użytkowników miesięcznie i niezawodności na poziomie 99,999%, nigdy nie będziesz musiał martwić się o przestoje, limity współbieżności lub jakiekolwiek opóźnienia spowodowane skokami ruchu.

Poznaj PubNub
-------------

Sprawdź [Live Tour](https://www.pubnub.com/tour/introduction/), aby zrozumieć podstawowe koncepcje każdej aplikacji opartej na PubNub w mniej niż 5 minut.

Rozpocznij konfigurację
-----------------------

Załóż [konto](https://admin.pubnub.com/signup/) PubNub, aby uzyskać natychmiastowy i bezpłatny dostęp do kluczy PubNub.

Rozpocznij
----------

[Dokumenty](https://www.pubnub.com/docs) PubNub pozwolą Ci rozpocząć pracę, niezależnie od przypadku użycia lub [zestawu SDK](https://www.pubnub.com/docs).