Jak dodać tablicę wyników i tabelę liderów do gry Unity

Tablice wyników i tabele liderów są kluczowymi aspektami w promowaniu zaangażowania graczy. Tablice wyników 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.

Chociaż tablice wyników i tabele wyników są niezbędne w tworzeniu gier, aby promować zdrową rywalizację i zapewniać istotne informacje zwrotne podczas gry, włączenie tych funkcji do projektu Unity jest łatwiej powiedzieć niż zrobić. Aby zacząć od zera, potrzeba wielu zasobów, aby zbudować, utrzymać i skalować, gdy liczba graczy wzrośnie, ponieważ będziesz musiał komunikować aktualizacje tablicy wyników i przechowywać zaktualizowane wyniki tabeli liderów, gdy się pojawią. Na szczęście PubNub sprawił, że wprowadzanie funkcji czasu rzeczywistego do gier Unity jest łatwiejsze niż kiedykolwiek dzięki naszej platformie API czasu rzeczywistego o niskim opóźnieniu. Dbamy o warstwę infrastrukturalną twoich aplikacji, dzięki czemu możesz skupić się na swojej aplikacji. 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 wielu platform, nasz Unity SDK zapewni Ci wszystko.

Jeśli chcesz zobaczyć przykład implementacji tablicy wyników i tabeli liderów w grze Unity, aby wykorzystać go jako punkt odniesienia podczas korzystania z tego przewodnika, koniecznie zapoznaj się z naszą grą pokazową Unity.

Kontynuuj czytanie, aby dowiedzieć się krok po kroku, jak dodać tablicę wyników i tablicę wyników do gry Unity, która aktualizuje się w czasie rzeczywistym, zaczynając od zrozumienia, jak skonfigurować PubNub GameObject, poznania funkcji PubNub i sposobu analizowania wiadomości PubNub w celu dostosowania ich do potrzeb gry.

Pierwsze kroki z PubNub

Zanim zaczniesz rozumieć, jak skonfigurować tablicę wyników i tabelę liderów dla swojej gry Unity, musisz zrozumieć PubNub i jak skonfigurować aplikację, aby korzystać z funkcji platformy.

Przegląd

PubNub opiera się na modelu Pub/Sub (publikuj/subskrybuj). Użytkownik publikuje 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ą sieć PubNub i analizują wiadomość. Odsłuchiwacze zdarzeń 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 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 publikować tylko jedną wiadomość na raz, użytkownik może subskrybować wiele różnych kanałów na raz.

Instalacja i konfiguracja PubNub Unity SDK

Aby rozpocząć, musisz zainstalować wszelkie zależności PubNub i skonfigurować PubNub Unity SDK, aby połączyć swoją aplikację z siecią PubNub. Niniejszy przewodnik zakłada, że masz już zainstalowany Unity Game Engine, Unity Assets i edytory kodu, takie jak Visual Studio. Aby uzyskać szczegółowe informacje, zapoznaj się z dokumentacją Un ity SDK, ale jako przegląd, będziesz musiał:

Dodać pakiet Unity za pośrednictwem Menedżera pakietów.
Utworzyć bezpłatne konto PubNub i uzyskać klucze PubNub. Musisz włączyć funkcje w swoim zestawie kluczy, których potrzebuje twoja aplikacja. Na potrzeby tego przewodnika należy włączyć Stream Controller z domyślnymi ustawieniami. Inna ważna funkcja, Functions, zostanie włączona automatycznie po zainicjowaniu funkcji, co zostanie omówione w dalszej części tego przewodnika.
Utwórz nowy projekt Unity lub otwórz istniejącą grę i podaj Unity klucze publikowania i subskrybowania uzyskane w poprzednim kroku, aby skonfigurować PubNub GameObject w edytorze Unity. Powinieneś również podać UserId, ponieważ każdy obiekt PubNub wymaga unikalnego identyfikatora w celu nawiązania połączenia z PubNub. Gdy to zrobisz, zainicjalizuj obiekt PubNub:

using PubnubApi;
using PubnubApi.Unity;
…
PubNub pubnub = new Pubnub(pnConfiguration);

Dodaj słuchacza zdarzeń dla swojej gry, aby reagować na wiadomości, gdzie twój back-end będzie zasadniczo otrzymywał powiadomienia o otrzymaniu nowych wiadomości. Istnieją różne detektory zdarzeń, aby móc zaimplementować niestandardową logikę reagowania na każdy typ wiadomości lub zdarzenia, ale w tym przewodniku będziesz potrzebował po prostu detektora zdarzeń wiadomości:

var listener = new SubscribeCallbackListener();
pubnub.AddListener(listener);
listener.onMessage += OnPnMessage;
…
private void OnPnMessage(Pubnub pn, PNMessageResult<object> result) {
  Debug.Log($"Message received: {result.Message}");
  //Handle the message based on channel name, User ID, etc.
}

Istotne informacje podczas meczów: Tablice wyników

Tablice wyników lub systemy punktacji są używane w grach jako sposób na dostarczenie graczowi informacji zwrotnej podczas gry. Tablice wyników są niezbędne do zapewnienia cennych, angażujących i satysfakcjonujących informacji zwrotnych, które zachęcają do przyjemnych wrażeń i powtarzalności w celu poprawy wyników. Zapoznaj się z naszym przewodnikiem po systemach punktacji na temat różnych typów tablic wyników, które możesz zaimplementować w swoim projekcie Unity.

Aktualizacja tablicy wyników podczas meczu jest zasadniczo taka sama jak wysyłanie wiadomości na czacie, ale z dużo większą szybkością: tworzysz ładunek składający się z niezbędnych informacji i publikujesz tę wiadomość dla wszystkich subskrybentów, aby mogli odbierać, analizować i aktualizować swoje tablice wyników za każdym razem, gdy pojawią się nowe informacje. Jeśli używasz PubNub do zasilania innych funkcji dla wielu graczy, takich jak synchronizacja dla wielu graczy, zaleca się łączenie tych informacji razem, ponieważ liczba wiadomości, które musisz wysłać, będzie ogromna i może pomóc zmniejszyć liczbę transakcji, które musisz wykonać. W tym przewodniku skupimy się jednak na funkcjach PubNub niezbędnych do wysyłania i odbierania wiadomości.

Aby rozpocząć wdrażanie tablicy wyników, należy skonfigurować wzorzec kanału, aby aktualizacje otrzymywały tylko osoby biorące udział w meczu. W zależności od architektury synchronizacji dla wielu graczy, powinieneś mieć jakiś rodzaj identyfikatora pokoju lub identyfikatora meczu, który jednoznacznie identyfikuje bieżący mecz z graczami. Użyj tego identyfikatora podczas tworzenia kanału:

public string scoreboardUpdates = $“scoreboard.” + {RoomID};

Kanał wykorzystuje interpolację ciągów znaków, aby połączyć kanał tablicy wyników i identyfikator bieżącego meczu. Subskrybuj ten kanał, aby móc nasłuchiwać jego aktualizacji:

pubnub.Subscribe<string>()
  .Channels(new string[] {
    // subscribe to channels
    scoreboardUpdates
   })
  .Execute();

Gdy będziesz mieć aktualizacje do wysłania, takie jak zabójstwo lub wzrost obrażeń, opublikuj aktualizację, konstruując wiadomość (na wypadek, gdybyś chciał wysłać więcej informacji niż tylko kilka aktualizacji tabeli wyników):

Dictionary<string, object> leaderboardUpdates= new Dictionary<string, object>();
leaderboardUpdates.Add("userId", user-a-uuid);
leaderboardUpdates.Add("kills", 0);
leaderboardUpdates.Add("deaths", 0);
leaderboardUpdates.Add("assists", 0);
leaderboardUpdates.Add("total_damage", 0);
…
private async void PublishMessage(string text, string channel)
{
  await PNManager.pubnubInstance.pubnub.Publish()
    .Channel(scoreboardUpdates)
    .Message(text)
    .ExecuteAsync();
}

Inni gracze otrzymają nowe aktualizacje za pośrednictwem odbiornika zdarzeń wiadomości, który skonstruowaliśmy wcześniej. Następnie przeanalizowałbyś wiadomość i odpowiednio zaktualizował ich interfejs użytkownika. Trwałoby to do zakończenia gry, w którym to przypadku wykonałbyś ostatnie połączenie, aby zaktualizować globalne tabele wyników.

Rankingi najlepszych wyników: Tablice wyników

Tablice wyników mają kluczowe znaczenie dla gier, aby zwiększyć rywalizację między graczami i są wyświetlane po zakończeniu meczów lub na ekranie głównym w osobnym menu. Gracze chcą być w stanie zobaczyć, jak dobrze radzą sobie w porównaniu z innymi graczami, gildiami i klanami oraz zobaczyć, jak mogą poprawić swój styl gry, aby osiągnąć wyższe wyniki. Jeśli chcesz dowiedzieć się więcej o różnych typach tabel wyników, które możesz zaimplementować w swojej grze Unity, zapoznaj się z naszym przewodnikiem po tabelach wyników.

Zanim zaczniemy implementować tablice wyników online, musimy porozmawiać o tym, w jaki sposób możemy nie tylko aktualizować tablicę wyników po zakończeniu meczów, ale także przechowywać informacje o tablicy wyników bez konieczności uruchamiania serwera.

Functions pozwala programistom tworzyć i wykonywać logikę biznesową na brzegu sieci w celu kierowania, filtrowania, przekształcania, rozszerzania i agregowania komunikatów w czasie rzeczywistym, gdy przechodzą one przez sieć PubNub. Możesz hostować tę logikę biznesową bez konieczności uruchamiania serwera, gdzie możesz zintegrować się z jedną z naszych zaufanych integracji stron trzecich (które są już skonfigurowane do pracy z Functions i zawierają instrukcje dotyczące rozpoczęcia pracy) lub napisać własny kod, aby wykonać niestandardową logikę przed lub po wysłaniu go z powrotem do graczy. Możesz nawet przechowywać odpowiednie informacje za pomocą modułu KV store, który jest trwałym magazynem wartości kluczowych, który działa jak baza danych dla twoich funkcji. Możesz dowiedzieć się więcej o funkcjach, zagłębiając się w naszą dokumentację.

W przypadku tabel liderów chcesz zaktualizować wyniki po zakończeniu meczu przez graczy, a następnie powiadomić graczy o zaktualizowanej tabeli liderów.

Aby móc korzystać z funkcji, należy przeprowadzić dodatkową konfigurację w portalu administratora:

Przejdź do Portalu administratora.
Kliknij zakładkę Funkcje po lewej stronie portalu.
Wybierz aplikację i zestaw kluczy utworzony w poprzedniej sekcji.
Kliknij przycisk Create New Module (Utwórz nowy moduł).
Nadaj modułowi nazwę.
Wprowadź opis działania modułu.
Wybierz utworzony wcześniej zestaw kluczy, aby dodać moduł. Kliknij przycisk Utwórz.
Nadaj funkcji nazwę.
Wybierz typ zdarzenia After Publish lub Fire.
Wprowadź nazwę kanału, który funkcja ma aktualizować po opublikowaniu wiadomości (można ją również dostosować później). Będziesz używać nazwy kanału, takiej jak score.*, składającej się ze znaku wieloznacznego Subscribe * the feature. Więcej informacji o tym, jak Wildcard Subscribe działa dla wiadomości czatu, można znaleźć w poniższym przewodniku.
Kliknij przycisk Utwórz dla każdej funkcji.

Zostaniesz przeniesiony na stronę przeglądu funkcji, gdzie możesz zmienić ustawienia, przetestować, a nawet monitorować funkcję podczas interakcji z grą dla każdej funkcji. Na środku ekranu powinien znajdować się automatycznie wygenerowany kod JavaScript. Jest to przykładowa funkcja "Hello World", aby pokazać przykład działania funkcji i miejsce, w którym można hostować swój kod lub wykonać logikę biznesową integracji stron trzecich.

W przypadku tabel liderów napiszesz niestandardową logikę i skorzystasz z modułu KV Store, aby zapisać informacje o tabeli liderów. W sekcji kodu należy rozważyć, jakie informacje będą zawierać tabele wyników. Czy będziesz mieć wiele tabel liderów z różnymi informacjami, dużą tabelę liderów zawierającą wiele statystyk, która umożliwi tworzenie różnych tabel liderów w grze?

Po ustaleniu, jakie informacje chcesz przechowywać, musisz skonfigurować ładunek wiadomości, który zostanie opublikowany w grze do sieci PubNub, a następnie przechwycony przez funkcję.

Na przykład w naszej grze Unity Showcase Game wysyłamy nazwę każdego gracza w meczu i jego wynik, który jest kombinacją ich zabójstw/śmierci/asyst po zakończeniu meczu. Wiadomość jest formatowana w JSON i publikowana na kanale score.leaderboard, którego funkcja nasłuchuje (w oparciu o Wildcard Subscribe). Spójrz w szczególności na plik UIManager.cs:

…
 // Get the kills and deaths value of all players and store them in an INT array:
 int[] kills = new int[playersSorted.Length];
 int[] deaths = new int[playersSorted.Length];
 int[] otherScore = new int[playersSorted.Length];
 for (int i = 0; i < playersSorted.Length; i++)
 {
   kills[i] = playersSorted[i].Kills;
   deaths[i] = playersSorted[i].Deaths;
   otherScore[i] = playersSorted[i].OtherScore;
   if (notPublished)
   {
     if (playersSorted[i].PlayerName == Connector.PNNickName)
     {
       MyClass mc = new MyClass();
       mc.username = Connector.PNNickName;
       mc.score = playersSorted[i].Kills.ToString();
       string json = JsonUtility.ToJson(mc);
       PublishMessage(json, _leaderboardChannelPub);
      }
      notPublished = false;
    }
  }
…

private async void PublishMessage(string text, string channel)
{
  await PNManager.pubnubInstance.pubnub.Publish()
    .Channel(channel)
    .Message(text)
    .ExecuteAsync();
}

Funkcja nasłuchująca na tym kanale zostanie następnie uruchomiona i będzie można sortować, aktualizować nowe wyniki w module sklepu KV i aktualizować graczy o nowe aktualizacje tabeli liderów. W przypadku gry Unity Showcase następująca logika w funkcji robi dokładnie to:

//This function takes a string from a unity game that contains either a username AND and a score, OR a refresh message.
//The function then looks at the message and creates a user/score json and sends it back. Putting the highest score in 0 and the lowest score in [9]
//If the score submitted is lower than [9] then trhe messages succeeds without intervention
//sending a refresh will trigger this function without any intervention.

export default (request) => {
  const db = require("kvstore");
  const pubnub = require("pubnub");
 //uncomment if you want to see the raw message
 //console.log(request.message);
 //The format of the message sent is "{\"username\":\"Bob\",\"score\":\"10\",\"refresh\":\"\"}"  and as such we need to parse it 
  //You wont be able to use the test payload until you remove the parse
  // var json = request.message; //uncomment this and comment the line below to be able to use the test payload (as well as debug console)
  var json = JSON.parse(request.message);
  let { username, score } = json;

  //create some arrays to ultimately be able to position the leaderboard correctly - there's more elegant ways to do this, this function is designed to explain
  var scorearrayprevious = [];
  var scorearraynew = [];
  var usernamearraynew = [];
  var usernamearrayprevious = [];

  //db.removeItem("data"); //uncomment this code if you need to wipe the database -- for future you could always send a message to trigger this, but that is out of the scope for this workshop
  db.get("data").then((value) => {
  if(value){
    console.log("value", value); //uncomment this if you want to see the value 
    let i = 0;
    //we use some and score > item to parse through where the submitted score will sit, if the score is greater than the item we're on, then it get's slotted in to the array at that spot
    value.score.some(item => {
        if(parseFloat(score) > parseFloat(item) || (parseFloat(item) == 0 && score.length > 0)){ //Parse into float since variables are currently strings
          //Score
          scorearraynew = value.score.slice(0, i);
          scorearrayprevious = value.score.slice(i, value.score.length);
          console.log("values", scorearraynew, scorearrayprevious);
          scorearraynew.push(score);
          var newScoreList = scorearraynew.concat(scorearrayprevious);
          newScoreList.splice(-1,1);

          //Username
          usernamearrayprevious = value.username.slice(0, i);
          usernamearraynew = value.username.slice(i, value.score.length);
          console.log("values", usernamearrayprevious, usernamearraynew);
          usernamearrayprevious.push(username);
          var newUsername = usernamearrayprevious.concat(usernamearraynew);
          newUsername.splice(-1,1);

          value.score = newScoreList;
          value.username = newUsername;
          //store the 
          db.set("data", value);

          return true; //break out of the loop using Array.prototype.some by returning true
       }
        i++;
    });
    //publish the message to a *new* or *different* channel 
    pubnub.publish({
        "channel": "leaderboard_scores",
        "message": value
    }).then((publishResponse) => {
        console.log("publish response", publishResponse);
    });
} else {
  //Initial Data, used only on the first call
    db.set("data", {
        "username":["---","---","---","---","---","---","---","---","---","---"], 
        "score":["0","0","0","0","0","0","0","0","0","0"]});
}
    }); 
    return request.ok();
};

Funkcja następnie publikuje aktualizacje tabeli liderów do wszystkich graczy za pośrednictwem kanału leaderboard_scores. W aplikacji należy zasubskrybować ten kanał za pomocą wywołania Subscribe:

pubnub.Subscribe<string>()
  .Channels(new string[] {
    // subscribe to channels
    "leaderboard_scores”
  })
  .Execute();

Ponieważ jesteś subskrybentem kanału leaderboard_scores, możesz otrzymywać zaktualizowane wyniki tabeli liderów od funkcji po jej zakończeniu za pośrednictwem Message Event Listener. Następnie można przeanalizować wiadomość i odpowiednio zaktualizować interfejs tablicy wyników. Na przykład, aby zaktualizować tabelę wyników Unity Showcase Game UI:

private void OnPnMessage(PNMessageResult<object> result)
{
  // Enable the button once we have established connection to PubNub 
  if (result.Channel.Equals(PubNubUtilities.chanLeaderboardSub))
  {
    Dictionary<string, object> msg = JsonConvert.DeserializeObject<Dictionary<string, object>>(result.Message.ToString());// as Dictionary<string, object>;
    var usernames = (msg["username"] as Newtonsoft.Json.Linq.JArray).ToObject<string[]>();
    var scores = (msg["score"] as Newtonsoft.Json.Linq.JArray).ToObject<string[]>();

    if (usernames[0] != null)
    {
        namePos1.text = usernames[0];
        kdPos1.text = scores[0];
    }

    if (usernames[1] != null)
    {
        namePos2.text = usernames[1];
        kdPos2.text = scores[1];
    }

    if (usernames[2] != null)
    {
        namePos3.text = usernames[2];
        kdPos3.text = scores[2];
    }

    if (usernames[3] != null)
    {
        namePos4.text = usernames[3];
        kdPos4.text = scores[3];
    }

    if (usernames[4] != null)
    {
        namePos5.text = usernames[4];
        kdPos5.text = scores[4];
    }
  }
}

Możesz zajrzeć do pliku Leaderboard.cs, aby uzyskać więcej informacji na temat implementacji tablicy wyników dla gry Unity Showcase Game.

Co dalej

Z tego przewodnika dowiedziałeś się, jak dodać tabelę wyników i tabelę wyników do gry Unity. Aby dodać tablicę wyników, można użyć platformy PubNub o niskim opóźnieniu do wysyłania i odbierania wiadomości zawierających istotne informacje podczas meczu, takie jak zabójstwa, zgony i asysty, aby aktualizować graczy w czasie rzeczywistym. W przypadku tabel liderów, Functions może hostować kod aktualizujący wyniki graczy i aktualizować tabele liderów, aby gracze mogli je przeglądać po zakończeniu meczu.

Twórcy gier mogą dowiedzieć się więcej z poniższych zasobów:

Przeczytaj naszą dokumentację.
Dowiedz się, jak dodać czat w czasie rzeczywistym w Unity.
Dowiedz się, jak nasza gra pokazowa Un ity implementuje tablicę wyników i tabelę liderów w czasie rzeczywistym.
Zanurz się w kodzie źródłowym Unity SDK.

W razie jakichkolwiek pytań lub wątpliwości zachęcamy do kontaktu z zespołem ds. relacji z deweloperami pod adresem devrel@pubnub.com.

Jak PubNub może ci pomóc?

Ten artykuł został pierwotnie opublikowany na PubNub.com

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

Podstawą naszej platformy jest największa w branży i najbardziej skalowalna sieć komunikacyjna 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.