So fügen Sie eine Anzeigetafel und ein Leaderboard zu Ihrem Unity-Spiel hinzu

Anzeigetafeln und Bestenlisten sind wichtige Aspekte bei der Förderung des Engagements der Spieler. Anzeigetafeln liefern wichtige Informationen, während die Spieler in ein intensives Match verwickelt sind, und sind notwendig, um die besten Gewinnchancen zu ermitteln, während Bestenlisten dazu dienen, den Wettbewerb zwischen den Spielern anzuregen, um die Highscores nach Matches zu sehen. Beides fördert die Wiederholbarkeit und ist ein einfacher Weg, um die Spielerbindung zu erhöhen.

Scoreboards und Leaderboards sind in der Spieleentwicklung unerlässlich, um einen gesunden Wettbewerb zu fördern und ein wichtiges Feedback während eines Spiels zu geben, aber diese Funktionen in Ihr Unity-Projekt zu integrieren ist leichter gesagt als getan. Wenn man von Null anfängt, braucht man eine Menge Ressourcen, um sie zu erstellen, zu warten und zu skalieren, wenn die Spielerzahl steigt, da man die Aktualisierungen der Anzeigetafeln kommunizieren und die aktualisierten Ergebnisse der Bestenlisten speichern muss, wenn sie auftreten. Zum Glück ist es mit PubNub einfacher als je zuvor, Echtzeitfunktionen in Unity-Spiele einzubauen - mit unserer Echtzeit-API-Plattform mit niedriger Latenzzeit. Wir kümmern uns um die Infrastrukturschicht Ihrer Anwendungen, damit Sie sich auf Ihre Anwendung konzentrieren können. Egal, ob Sie für Windows, Mac, iOS, Android, Virtual Reality-Systeme wie Oculus und Meta Quest oder plattformübergreifend entwickeln, unser Unity SDK deckt Sie ab.

Wenn Sie ein Beispiel für die Implementierung einer Anzeigetafel und eines Leaderboards in einem Unity-Spiel sehen möchten, das Sie als Referenz verwenden können, wenn Sie dieser Anleitung folgen, sollten Sie sich unser Unity Showcase Game ansehen.

Lies weiter, um Schritt für Schritt zu lernen, wie du eine Anzeigetafel und ein Leaderboard zu deinem Unity-Spiel hinzufügst, das in Echtzeit aktualisiert wird. Du erfährst, wie du das PubNub GameObject konfigurierst, wie du die PubNub-Funktionen kennenlernst und wie du die PubNub-Nachrichten analysierst, um sie an die Bedürfnisse deines Spiels anzupassen.

Erste Schritte mit PubNub

Bevor du verstehst, wie du eine Anzeigetafel und ein Leaderboard für dein Unity-Spiel einrichtest, musst du PubNub verstehen und wissen, wie du deine Anwendung so konfigurierst, dass sie von den Funktionen der Plattform profitiert.

Überblick

PubNub basiert auf dem Pub/Sub (Publish/Subscribe) Modell. Ein Benutzer veröffentlicht 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 das PubNub-Netzwerk und analysieren die Nachricht. Ereignis-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 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 jeweils nur eine Nachricht veröffentlichen kann, kann ein Benutzer viele verschiedene Kanäle gleichzeitig abonnieren.

Installieren und konfigurieren Sie das PubNub Unity SDK

Zu Beginn müssen Sie alle PubNub-Abhängigkeiten installieren und das PubNub Unity SDK konfigurieren, um Ihre Anwendung mit dem PubNub-Netzwerk zu verbinden. In dieser Anleitung wird davon ausgegangen, dass Sie bereits die Unity Game Engine, Unity Assets und Code-Editoren wie Visual Studio installiert haben. Bitte lesen Sie die Unity SDK-Dokumentation für alle Details, aber als Überblick müssen Sie Folgendes tun:

Fügen Sie das Unity-Paket über den Paketmanager hinzu.
Erstellen Sie ein kostenloses PubNub-Konto und erhalten Sie Ihre PubNub-Keys. Sie müssen die Funktionen Ihres Keysets aktivieren, die Ihre Anwendung benötigt. Für diese Anleitung müssen Sie den Stream Controller mit den Standardeinstellungen aktivieren. Das andere wichtige Feature, Functions, wird automatisch aktiviert, sobald du die Function initialisierst, was später in diesem Leitfaden besprochen wird.
Erstellen Sie ein neues Unity-Projekt oder öffnen Sie Ihr bestehendes Spiel und geben Sie Unity die Publish- und Subscribe-Keys, die Sie im vorherigen Schritt erhalten haben, um das PubNub GameObject im Unity-Editor zu konfigurieren. Du solltest auch eine UserId angeben, da jedes PubNub-Objekt einen eindeutigen Identifikator benötigt, um eine Verbindung zu PubNub herzustellen. Danach initialisieren Sie das PubNub-Objekt:

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

Fügen Sie einen Ereignis-Listener für Ihr Spiel hinzu, um auf Nachrichten zu reagieren, wobei Ihr Backend im Wesentlichen Benachrichtigungen darüber erhält, wenn Sie neue Nachrichten erhalten. Es gibt verschiedene Event-Listener, mit denen du eigene Logik implementieren kannst, um auf jede Art von Nachricht oder Ereignis zu reagieren, aber für diese Anleitung brauchst du nur den Message Event Listener:

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.
}

Wichtige Informationen während der Spiele: Anzeiger

Anzeigetafeln oder Punktesysteme werden in Spielen verwendet, um den Spielern während eines Spiels Feedback zu geben. Anzeigetafeln sind wichtig, um wertvolles, ansprechendes und lohnendes Feedback zu geben, das ein angenehmes Spielerlebnis und die Wiederholbarkeit fördert, um den Spielstand zu verbessern. In unserem Leitfaden für Punktesysteme finden Sie Informationen zu den verschiedenen Arten von Anzeigetafeln, die Sie in Ihr Unity-Projekt einbauen können.

Die Aktualisierung der Anzeigetafel während eines Spiels ist im Wesentlichen dasselbe wie das Senden von Chat-Nachrichten, aber mit einer viel höheren Rate: Sie konstruieren eine Nutzlast, die aus den notwendigen Informationen besteht, und veröffentlichen diese Nachricht für alle Abonnenten, um sie zu empfangen, zu analysieren und ihre Anzeigetafeln zu aktualisieren, sobald neue Informationen auftreten. Wenn Sie PubNub verwenden, um andere Multiplayer-Funktionen wie die Multiplayer-Synchronisation zu betreiben, ist es empfehlenswert, diese Informationen zu bündeln, da die Anzahl der zu sendenden Nachrichten enorm sein wird und die Anzahl der erforderlichen Transaktionen reduziert werden kann. Dieser Leitfaden konzentriert sich jedoch nur auf die PubNub-Funktionen, die zum Senden und Empfangen von Nachrichten erforderlich sind.

Um mit der Implementierung Ihrer Anzeigetafel zu beginnen, richten Sie ein Channel-Muster ein, damit nur diejenigen, die am Spiel teilnehmen, die Aktualisierungen erhalten. Abhängig von deiner Architektur für die Multiplayer-Synchronisation solltest du eine Art Raum-ID oder Match-ID haben, die ein aktuelles Match mit Spielern eindeutig identifiziert. Verwenden Sie diese ID, wenn Sie Ihren Channel erstellen:

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

Der Channel verwendet eine String-Interpolation, um den Anzeigetafel-Channel und die Kennung des aktuellen Matches zu kombinieren. Abonnieren Sie diesen Channel, um auf Channel-Updates zu warten:

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

Sobald Sie Aktualisierungen zu senden haben, z. B. wenn Sie einen Kill erzielen oder Ihr Schadenswert steigt, veröffentlichen Sie die Aktualisierung, indem Sie eine Nachricht erstellen (falls Sie auch mehr Informationen als nur ein paar Aktualisierungen der Anzeigetafel senden möchten):

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

Die anderen Spieler würden die neuen Aktualisierungen über den zuvor erstellten Nachrichten-Ereignis-Listener erhalten. Sie würden dann die Nachricht auswerten und ihre Benutzeroberfläche entsprechend aktualisieren. Dieser Vorgang wird bis zum Ende des Spiels fortgesetzt. In diesem Fall machen Sie einen letzten Aufruf, um die globalen Ranglisten zu aktualisieren.

High-Score-Ranglisten: Bestenlisten

Bestenlisten sind wichtig für Spiele, um den Wettbewerb unter den Spielern zu erhöhen. Sie werden nach dem Ende eines Spiels oder auf dem Startbildschirm in einem separaten Menü angezeigt. Die Spieler wollen sehen, wie gut sie im Vergleich zu anderen Spielern, Gilden und Clans abschneiden und wie sie ihren Spielstil verbessern können, um höhere Punktzahlen zu erreichen. Wenn ihr mehr über die verschiedenen Arten von Bestenlisten erfahren möchtet, die ihr in euer Unity-Spiel einbauen könnt, schaut euch unseren Leitfaden zu Bestenlisten an.

Bevor wir mit der Implementierung einer Online-Rangliste beginnen, müssen wir darüber sprechen, wie wir die Rangliste nicht nur aktualisieren können, sobald die Spiele beendet sind, sondern auch die Ranglisteninformationen speichern können, ohne den Server hochfahren zu müssen.

Funktionen ermöglichen es Entwicklern, Geschäftslogik am Rand zu erstellen und auszuführen, um Echtzeitnachrichten zu routen, zu filtern, zu transformieren, zu erweitern und zu aggregieren, während sie durch das PubNub-Netzwerk geleitet werden. Sie können diese Geschäftslogik hosten, ohne dass Sie Ihren Server hochfahren müssen, wo Sie eine unserer bewährten Integrationen von Drittanbietern integrieren können (die bereits für die Arbeit mit Funktionen eingerichtet sind und Anleitungen für die ersten Schritte enthalten) oder Ihren eigenen Code schreiben, um eine benutzerdefinierte Logik vor oder nach dem Zurücksenden an die Spieler auszuführen. Sie können sogar relevante Informationen mit dem KV-Speichermodul speichern, das ein dauerhafter Schlüsselwertspeicher ist, der als Datenbank für Ihre Funktionen dient. Mehr über Funktionen erfahren Sie in unserer Dokumentation.

Für Bestenlisten möchten Sie die Punktestände aktualisieren, nachdem die Spieler ein Spiel beendet haben, und dann die Spieler über die aktualisierte Bestenliste informieren.

Um Funktionen verwenden zu können, müssen Sie einige weitere Einstellungen im Admin-Portal vornehmen:

Navigieren Sie zum Verwaltungsportal.
Klicken Sie auf die Registerkarte Funktionen auf der linken Seite des Portals.
Wählen Sie die App und das Keyset aus, die Sie im vorherigen Abschnitt erstellt haben.
Klicken Sie auf Neues Modul erstellen.
Geben Sie dem Modul einen Namen.
Geben Sie eine Beschreibung der Funktion des Moduls ein.
Wählen Sie das Keyset, das Sie zuvor erstellt haben, um das Modul hinzuzufügen. Klicken Sie auf Erstellen.
Geben Sie der Funktion einen Namen.
Wählen Sie den Ereignistyp Nach Veröffentlichung oder Feuer.
Geben Sie den Namen des Channels ein, den die Funktion nach der Veröffentlichung einer Nachricht aktualisieren soll (dies kann auch später noch angepasst werden). Sie werden einen Channel-Namen wie score.* verwenden, der aus dem Platzhalterzeichen Subscribe * für die Funktion besteht. Mehr über die Funktionsweise von Wildcard Subscribe für Chatnachrichten erfahren Sie in der folgenden Anleitung.
Klicken Sie für jede Funktion auf die Schaltfläche Erstellen.

Sie gelangen auf die Übersichtsseite der Funktion, auf der Sie die Einstellungen ändern, testen und sogar die Funktion überwachen können, wenn sie mit Ihrem Spiel interagiert. In der Mitte des Bildschirms sollte automatisch generierter JavaScript-Code angezeigt werden. Dies ist eine "Hello World"-Beispielfunktion, um zu zeigen, wie eine Funktion funktioniert und wo Sie entweder Ihren Code hosten oder die Geschäftslogik der Integration von Drittanbietern ausführen können.

Für die Bestenlisten werden Sie eine benutzerdefinierte Logik schreiben und das KV Store Modul verwenden, um die Informationen der Bestenliste zu speichern. Im Code-Abschnitt müssen Sie sich überlegen, was die Informationen in der Bestenliste enthalten sollen. Möchten Sie mehrere Ranglisten mit unterschiedlichen Informationen haben, eine große Rangliste, die mehrere Statistiken enthält, die es Ihnen ermöglichen, verschiedene Ranglisten in Ihrem Spiel zu erstellen?

Sobald Sie festgelegt haben, welche Informationen Sie speichern möchten, müssen Sie den Nachrichten-Payload einrichten, der in Ihrem Spiel im PubNub-Netzwerk veröffentlicht und dann von der Funktion abgefangen werden soll.

In unserem Unity Showcase Game senden wir zum Beispiel den Namen jedes Spielers im Match und seinen Punktestand, der sich aus einer Kombination von Kills/Deaths/Assists zusammensetzt, wenn er ein Match beendet. Die Nachricht wird in JSON formatiert und auf dem Kanal score.leaderboard veröffentlicht, den die Funktion abhört (basierend auf dem Wildcard Subscribe). Werfen Sie einen Blick auf die Datei 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();
}

Die Funktion, die diesen Kanal abhört, wird dann ausgelöst, und Sie können dann sortieren, die neuen Spielstände im KV-Speichermodul aktualisieren und die Spieler über die neuen Leaderboard-Aktualisierungen informieren. Für das Unity Showcase Game tut die folgende Logik in der Funktion genau das:

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

Die Funktion veröffentlicht dann die Aktualisierungen der Bestenliste an alle Spieler über den channel leaderboard_scores. Zurück in Ihrer Anwendung müssen Sie diesen Channel über den Aufruf Subscribe abonnieren:

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

Da Sie den channel leaderboard_scores abonniert haben, können Sie die aktualisierten Ergebnisse der Bestenliste von der Funktion empfangen, sobald diese über den Message Event Listener beendet ist. Sie können dann die Nachricht analysieren und Ihre Leaderboard-Benutzeroberfläche entsprechend aktualisieren. Zum Beispiel, um die Unity Showcase Game UI-Leaderboard zu aktualisieren:

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

Weitere Details zur Leaderboard-Implementierung für das Unity Showcase Game finden Sie in der Datei Leaderboard.cs.

Was kommt als Nächstes?

In dieser Anleitung haben Sie gelernt, wie Sie ein Leaderboard und eine Anzeigetafel zu Ihrem Unity-Spiel hinzufügen können. Um eine Anzeigetafel hinzuzufügen, können Sie die PubNub-Plattform mit niedriger Latenz nutzen, um Nachrichten mit relevanten Informationen während eines Matches zu senden und zu empfangen, wie z. B. Kills, Tode und Assists, um die Spieler in Echtzeit zu informieren. Für Bestenlisten können Funktionen Code hosten, um die Spielergebnisse zu aktualisieren und die Bestenlisten zu aktualisieren, die die Spieler nach Abschluss ihres Matches einsehen können.

Spieleentwickler können mit den folgenden Ressourcen mehr erfahren:

Lesen Sie unsere Dokumentation.
Erfahren Sie , wie Sie einen Echtzeit-Chat in Unity hinzufügen können.
Verstehen Sie, wie unser Unity Showcase Game ein Scoreboard und Leaderboard in Echtzeit implementiert.
Tauchen Sie in den Quellcode des Unity SDK ein.

Wenden Sie sich an das Developer Relations Team unter devrel@pubnub.com, wenn Sie Fragen oder Bedenken haben.

Wie kann PubNub Ihnen helfen?

Dieser Artikel wurde ursprünglich auf PubNub.com veröffentlicht.

Unsere Plattform unterstützt Entwickler 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.