Photon-Schnellstart

  • Artikel

In dieser Schnellstartanleitung erfahren Sie, wie Sie Photon Multiplayer für die Verwendung mit PlayFab einrichten. Derzeit bietet PlayFab die folgenden Photon-Integrationen:

  • Authentifizieren Sie Photon-Spieler mit PlayFab.
  • Lauschen auf Raumereignisse mithilfe von PlayFab CloudScript-Rückrufen.

In dieser Schnellstartanleitung wird anhand des neuesten Photon Unity-Beispielprojekts veranschaulicht, wie beide Features funktionieren.

Notiz

Weitere Informationen zu einer vollständig unterstützten PlayFab Multiplayer- und Chaterfahrung in Unity finden Sie im Unity-Plug-In für PlayFab-Party .

Voraussetzungen

  1. Ein Unity-Projekt mit importiertem PlayFab SDK und einem konfigurierten Titel.
  2. Der registrierte PlayFab-Titel.

Notiz

In diesem Leitfaden werden die Chatanwendungseinstellungen weggelassen. Damit Ihre Chatanwendung integriert wird, erstellen Sie eine neue Photon Chat-Anwendung, und geben Sie die App-ID in den entsprechenden Feldern in Unity und auf der Seite PlayFab Game Manager – Photon Add-On ein.

Einrichten einer Photon-Anwendung

  1. Nachdem Sie sich beim Photon-Dashboard registriert und angemeldet haben, wählen Sie Neue App erstellen aus.

Erstellen einer neuen Photon-Anwendung

  1. Wählen Sie Photon-Typ aus.
  2. Wählen Sie einen Namen aus.
  3. Erstellen Sie eine Beschreibung.
  4. Senden Sie, indem Sie Erstellen auswählen.

Neues Antragsformular

Einrichten der Authentifizierung

  1. Suchen Sie die neu erstellte Anwendung in der Liste, und wählen Sie Verwalten aus.

Verwalten der Testanwendung

  1. Suchen und speichern Sie im Dashboard die App-ID, die sich unter der Seite Titel befindet.

Speichern der App-ID

  1. Suchen Sie den Abschnitt Authentifizierung .
  2. Wählen Sie den benutzerdefinierten Server aus.

Benutzerdefinierte Serverauthentifizierung

Auf der nächsten Seite können Sie die Authentifizierungs-URL für Photon konfigurieren.

https://{PlayFabTitleId}.playfabapi.com/photon/authenticate

Ersetzen Sie den PlayFabTitleId Platzhalter durch Ihre eigene Titel-ID.

{PlayFabTitleId}
  1. Geben Sie die URL ein.
  2. Senden Sie, indem Sie die Schaltfläche Erstellen auswählen.

Authentifizierungs-URL eingeben

Einrichten eines PlayFab-Titels für Photon

Navigieren Sie zur Game Manager-Seite Ihres Titels und dann:

  1. Navigieren Sie zur Registerkarte Add-Ons .
  2. Suchen Sie in der Liste der Add-Onsnach Photon, und wählen Sie es aus.

Registerkarte

  1. Auf der Photon-Add-On-Seite können Sie Photon installieren, indem Sie Ihre Photon Realtime-Anwendungs-ID angeben.
    • Optional können Sie die Chat-App-ID angeben.
    • Nach der Installation des Add-Ons (3) wird ein geheimer Photon-Schlüssel generiert (2).
    • Speichern Sie es für die zukünftige Verwendung beim Konfigurieren von Webhooks.

Notiz

Denken Sie daran, Ihren geheimen Photon-Schlüssel an einem sicheren und leicht zugänglichen Ort zu speichern. Dies ist beim Konfigurieren von Webhooks praktisch.

Kopieren der Echtzeit-App-ID

Festlegen von Photon-Webhooks

Als optionale Integration kann Photon bestimmte Ereignisse an Ihr PlayFab CloudScript übertragen. Dies erfolgt mit Webhooks:

  • Sie geben eine Basis-URL an.
  • Anschließend geben Sie den Pfad für jedes der verfügbaren Ereignisse an.
  • Ein Pfad ist im Grunde ein Handlername, der in Ihrem CloudScript implementiert wird.

Die Basis-URL hat das folgende Format:

https://{PlayFabTitleId}.playfablogic.com/webhook/1/prod/{PhotonSecretKey}

Stellen Sie sicher, dass Sie den Platzhalter durch Ihre eigene Titel-ID ersetzen Title Id .

{PlayFabTitleId}

Ersetzen Sie das PhotonSecretKey Token durch den geheimen Schlüssel, den Sie auf der Photon-Add-On-Seite generiert haben.

{PhotonSecretKey}
  1. Geben Sie die Basis-URL ein.
  2. Weisen Sie jedem der verfügbaren Ereignisse einen CloudScript-Handlernamen zu.
  3. Entfernen Sie alle CustomHttpHeaders.
  4. Senden Sie dies, indem Sie auf die Schaltfläche Speichern klicken.

Zuweisen von CloudScript-Ereignishandlern

Einrichten eines Unity-Projekts

In diesem Leitfaden wird davon ausgegangen, dass Sie das PlayFab SDK bereits importiert, eingerichtet und die Titeleinstellung konfiguriert haben.

  • Navigieren Sie zunächst zum Asset Store.
  • Suchen Sie nach photon Unity Networking Free-Paket.
  • Wählen Sie Importieren (1) aus.
  • Sie können die importierten Dateien überprüfen.
  • Wählen Sie dann Importieren (2) aus.

Importieren von Photon Unity

Direkt nach Abschluss des Importvorgangs wird das Fenster PUN Setup geöffnet.

  • Geben Sie Ihre Echtzeitanwendungs-ID (1) ein, die Sie im Photon-Anwendungsdashboard für die von Ihnen erstellte Photon-App gefunden haben.
  • Wählen Sie Projekt einrichten (2) aus.
  • Wählen Sie nach Abschluss des Setups Schließen (3) aus.

PUN-Setup

Wenn AppId akzeptiert wurde, wird das Photon Server Settings-Objekt ausgewählt und im Unity Inspector-Fenster angezeigt. So greifen Sie manuell auf das Objekt Servereinstellungen zu:

  • Navigieren Sie zum oberen Fensterbereich.
  • Wählen Sie Fenster aus.
  • Wählen Sie dann Photon Unity Networking (1) aus.
  • Wählen Sie abschließend Servereinstellungen hervorheben (2) aus.
  • Im Standard-Projektfenster von Unity wird das PhotonServerSettings (3)- Objekt angezeigt.
  • Wählen Sie das Objekt aus, um seine Einstellungen im Unity Inspector-Fenster anzuzeigen.

Photon-Servereinstellungen

Notiz

Im Rahmen von PhotonServerSettings haben Sie die Möglichkeit, die Chatanwendungs-ID zuzuweisen.

An diesem Punkt ist das Projekt konfiguriert.

Implementieren der Authentifizierung zwischen PlayFab und Photon

Wenn Sie das Photon-Add-On für Ihren Titel im PlayFab-Spiel-Manager aktivieren und die Authentifizierung im photon Application Dashboard konfigurieren, können Sie mit PlayFab vorhandene PlayFab-Spieler in der Photon-Umgebung authentifizieren.

Dies bedeutet, dass Sie die Implementierung einer Benutzerverwaltung für Photon vollständig vermeiden können.

  1. Navigieren Sie aus dem Photon Unity Networking Free-Paket, der klassischen Version, zur DemoHub-Scene-V2-Szene.
    • Diese Szene ist ein Hub für alle Beispiele aus dem Paket.
    • Da es sich um die erste zu ladende Szene handelt, fügen wir ein kleines Skript hinzu, um die Authentifizierung von PlayFab mit Photon zu ermöglichen.
  2. Erstellen Sie ein leeres GameObject mit dem Namen PlayFabAuthenticator.
  3. Fügen Sie dann im Unity Inspector-Fenster diesem GameObject eine Komponente mit demselben Namen hinzu.

Authentifizierungskomponente hinzufügen

Wählen Sie das Zahnradsymbol und dann aus dem Dropdownmenü aus, um das Skript zu bearbeiten. Kopieren Sie den Code für die Komponente, fügen Sie ihn PlayFabAuthenticator ein, speichern und schließen Sie die Datei.

using PlayFab;
using PlayFab.ClientModels;
using UnityEngine;

public class PlayFabAuthenticator : MonoBehaviour {

    private string _playFabPlayerIdCache;

    //Run the entire thing on awake
    public void Awake() {
        AuthenticateWithPlayFab();
    }

    /*
     * Step 1
     * We authenticate a current PlayFab user normally.
     * In this case we use the LoginWithCustomID API call for simplicity.
     * You can absolutely use any Login method you want.
     * We use PlayFabSettings.DeviceUniqueIdentifier as our custom ID.
     * We pass RequestPhotonToken as a callback to be our next step, if
     * authentication was successful.
     */
    private void AuthenticateWithPlayFab(){
        LogMessage("PlayFab authenticating using Custom ID...");

        PlayFabClientAPI.LoginWithCustomID(new LoginWithCustomIDRequest()
        {
            CreateAccount = true,
            CustomId = PlayFabSettings.DeviceUniqueIdentifier
        }, RequestPhotonToken, OnPlayFabError);
    }

    /*
    * Step 2
    * We request a Photon authentication token from PlayFab.
    * This is a crucial step, because Photon uses different authentication tokens
    * than PlayFab. Thus, you cannot directly use PlayFab SessionTicket and
    * you need to explicitly request a token. This API call requires you to
    * pass a Photon App ID. The App ID may be hard coded, but in this example,
    * we are accessing it using convenient static field on PhotonNetwork class.
    * We pass in AuthenticateWithPhoton as a callback to be our next step, if
    * we have acquired the token successfully.
    */
    private void RequestPhotonToken(LoginResult obj) {
        LogMessage("PlayFab authenticated. Requesting photon token...");

        //We can player PlayFabId. This will come in handy during next step
        _playFabPlayerIdCache = obj.PlayFabId;

        PlayFabClientAPI.GetPhotonAuthenticationToken(new GetPhotonAuthenticationTokenRequest()
        {
            PhotonApplicationId = PhotonNetwork.PhotonServerSettings.AppSettings.AppIdRealtime
        }, AuthenticateWithPhoton, OnPlayFabError);
    }

    /*
     * Step 3
     * This is the final and the simplest step. We create a new AuthenticationValues instance.
     * This class describes how to authenticate a player inside the Photon environment.
     */
    private void AuthenticateWithPhoton(GetPhotonAuthenticationTokenResult obj) {
        LogMessage("Photon token acquired: " + obj.PhotonCustomAuthenticationToken + "  Authentication complete.");

        //We set AuthType to custom, meaning we bring our own, PlayFab authentication procedure.
        var customAuth = new Photon.Realtime.AuthenticationValues { AuthType = CustomAuthenticationType.Custom };

        //We add "username" parameter. Do not let it confuse you: PlayFab is expecting this parameter to contain player PlayFab ID (!) and not username.
        customAuth.AddAuthParameter("username", _playFabPlayerIdCache);    // expected by PlayFab custom auth service

        //We add "token" parameter. PlayFab expects it to contain Photon Authentication Token issues to your during previous step.
        customAuth.AddAuthParameter("token", obj.PhotonCustomAuthenticationToken);

        //We finally tell Photon to use this authentication parameters throughout the entire application.
        PhotonNetwork.AuthValues = customAuth;
    }

    private void OnPlayFabError(PlayFabError obj) {
        LogMessage(obj.GenerateErrorReport());
    }

    public void LogMessage(string message) {
        Debug.Log("PlayFab + Photon Example: " + message);
    }
}

Testen der Authentifizierung zwischen PlayFab und Photon

  1. Starten Sie die Szene.
  2. Überprüfen Sie den Fluss von Konsolenmeldungen. Steuern, dass:
  3. Die Authentifizierung bei PlayFab selbst war erfolgreich.
  4. Das Photon-Token wurde abgerufen.

Die folgende Abbildung veranschaulicht den richtigen Ablauf.

Starten der Szene

Sobald das Photon-Token abgerufen wurde und die Authentifizierung abgeschlossen ist, können wir uns die Photon-Demos ansehen.

Starten Sie beispielsweise eine Demo namens Demo Boxes.

  1. Um sicherzustellen, dass die PlayFab-Authentifizierung abgeschlossen ist, wählen Sie Demoboxen aus.
  2. Wählen Sie dann Demo laden aus, wie in der folgenden Abbildung dargestellt.

Demo laden

Photon beginnt mit der Ausgabe von Debugmeldungen. Wenn Sie Ihre Konsole überwachen, können Sie leicht erkennen, ob Authentifizierungsprobleme vorliegen.

Photon-Debugkonsole

Stellen Sie sicher, dass in der Konsole keine Fehler vom Typ "Authentifizierung verweigert " vorhanden sind. An diesem Punkt haben Sie eine minimale PlayFab- und Photon-Integration eingerichtet.

Photon-Raumereignis + CloudScript

Das Photon Matchmaking-System hat das Konzept eines Raums. Wenn Sie mit diesem Konzept nicht vertraut sind, wenden Sie sich an den Photon Matchmaking Guide( Photon Matchmaking Guide).

Mit PlayFab können Sie verschiedene Raumereignisse abfangen. Für die folgenden Raumereignisse muss nur CloudScript abgefangen werden:

  • RoomCreated
  • RoomJoined
  • RoomLeft
  • RoomClosed

Die folgenden Ereignisse erfordern zusätzliche Kontrolle über Unity-Code, um abgefangen zu werden (Details finden Sie weiter unten in diesem Dokument):

  • RoomPropertyUpdated
  • RoomEventRaised

Notiz

Nachdem Sie einen Handler für ein Raumereignis eingeführt haben, wird er zu einem wichtigen Bestandteil des Ereignisbehandlungsablaufs. Daher können Fehler, die beim Ausführen Ihres CloudScripts auftreten, Probleme für das gesamte System verursachen. Wenn der RoomCreated Handler beispielsweise einen Fehler auslöst, lösen Ihre Clients ebenfalls einen Fehler aus und können keine ordnungsgemäße Verbindung herstellen.

Lassen Sie uns ein PlayFab CloudScript erstellen, indem Sie einen Handler für jeden Ereignistyp einzeln definieren.

Handler für Raumerstellung

Der RoomCreated Handler wird jedes Mal aufgerufen, wenn ein Photon-Raum erstellt wird. Der folgende CloudScript-Handler fängt solche Ereignisse ab.

// Triggered automatically when a Photon room is first created
handlers.RoomCreated = function (args) {
    return { ResultCode : 0, Message: 'Success' };
};

Notiz

Sie können mit dem Argument "args" weitere Daten über das Ereignis abrufen.

{
  "ActorNr": 1,
  "AppVersion": "1.2_1.85",
  "AppId": "bfd5f98b-c6a4-4763-80d9-824d20db842b",
  // Options with which the room was created.
  "CreateOptions": {
    "MaxPlayers": 4,
    "LobbyId": null,
    "LobbyType": 0,
    "CustomProperties": {

    },
    "EmptyRoomTTL": 0,
    "PlayerTTL": 0,
    "CheckUserOnJoin": false,
    "DeleteCacheOnLeave": true,
    "SuppressRoomEvents": false,
    "PublishUserId": false,
    "ExpectedUsers": null
  },
  // Unique game identifier
  "GameId": "8b8322de-096d-4481-a2b2-8db8bb45cfef",
  "Region": "EU",
  "Type": "Create",
  // User that caused the room to be created
  "UserId": "834D5AA5BAB1DFB6",
  "Username": ""
}

Room Joined-Handler

Der RoomJoined Handler wird jedes Mal aufgerufen, wenn ein Spieler dem Raum beitritt. Der folgende CloudScript-Handler fängt ein solches Ereignis ab.

// Triggered automatically when a player joins a Photon room
handlers.RoomJoined = function (args) {
    return { ResultCode : 0, Message: 'Success' };
};

Dieser Rückruf wird nicht für den ersten Benutzer aufgerufen, der den Raum betritt. Verwenden Sie RoomCreated , um den ersten Spieler abzufangen, der beitritt. Sie können mit dem Argument "args" weitere Daten über das Ereignis abrufen.

{
  "ActorNr": 2,
  "AppVersion": "1.2_1.85",
  "AppId": "bfd5f98b-c6a4-4763-80d9-824d20db842b",
  // Unique Game Identifier
  "GameId": "b0f55a2e-431d-402a-9809-b0240443267e",
  "Region": "EU",
  "Type": "Join",
  // Id of the player that has joined
  "UserId": "AAC7634BF46289DF",
  "Username": ""
}

Raum links

Der RoomLeft Handler wird jedes Mal aufgerufen, wenn ein Spieler den Raum verlässt. Der folgende CloudScript-Handler fängt ein solches Ereignis ab.

// Triggered automatically when a player leaves a Photon room
handlers.RoomLeft = function (args) {
    return { ResultCode : 0, Message: 'Success' };
};

Sie können weitere Daten über das Ereignis mit dem Argument "args" abrufen.

{
  "ActorNr": 2,
  "AppVersion": "1.2_1.85",
  "AppId": "bfd5f98b-c6a4-4763-80d9-824d20db842b",
  // Unique Game Identifier
  "GameId": "b0f55a2e-431d-402a-9809-b0240443267e",
  "IsInactive": false,
  "Reason": "0",
  "Region": "EU",
  "Type": "ClientDisconnect",
  // Id of the user that has left the room
  "UserId": "AAC7634BF46289DF",
  "Username": ""
}

Raum geschlossener Handler

Der RoomClosed Handler wird jedes Mal aufgerufen, wenn der letzte Spieler den Raum verlässt und kein Spieler mehr übrig ist. Der folgende CloudScript-Handler fängt ein solches Ereignis ab.

// Triggered automatically when a Photon room closes
// Note: currentPlayerId is undefined in this function
handlers.RoomClosed = function (args) {
    return { ResultCode : 0, Message: 'Success' };
};

Sie können weitere Daten über das Ereignis mit dem Argument "args" abrufen.

  "ActorCount": 0,
  "ActorNr": 1,
  "AppVersion": "1.2_1.85",
  "AppId": "bfd5f98b-c6a4-4763-80d9-824d20db842b",
  // Unique game identifier
  "GameId": "b0f55a2e-431d-402a-9809-b0240443267e",
  "Region": "EU",
  "State2": {
    "ActorList": [

    ]
  },
  "Type": "Close"
}

Room-Eigenschaft aktualisiert

Der RoomPropertyUpdated Handler wird bei jeder Änderung der Raumeigenschaft aufgerufen. Der folgende CloudScript-Handler fängt ein solches Ereignis ab.

// Triggered automatically when a Photon room game property is updated.
// Note: currentPlayerId is undefined in this function
handlers.RoomPropertyUpdated = function (args) {
    return { ResultCode : 0, Message: 'Success' };
};

Notiz

ist currentPlayerId in diesem Handler nicht definiert. Wenn die Raumeigenschaft vom Client geändert wurde, können Sie das Argument "args" verwenden und auf die UserId verweisen, um den verantwortlichen Spieler zu erwerben.

Sie können weitere Daten über das Ereignis mit dem Argument "args" abrufen.

{
  "ActorNr": 1,
  "AppVersion": "1.2_1.85",
  "AppId": "bfd5f98b-c6a4-4763-80d9-824d20db842b",
  // Custom Room Properties
  "Properties": {
    "CustomProperty": "It's Value"
  },
  "GameId": "8b8322de-096d-4481-a2b2-8db8bb45cfef",
  "Region": "EU",
  "State": {
    "ActorCounter": 1,
    "ActorList": [
      {
        "ActorNr": 1,
        "UserId": "834D5AA5BAB1DFB6",
        "Username": "",
        "IsActive": true,
        "Binary": "RGIAAAEBRAAAAAFi\/3MAAA==",
        "DEBUG_BINARY": {
          "1": {
            "255": ""
          }
        }
      }
    ],
    "Binary": {
      "18": "RAAAAANi+nkAAHNzAA1QbGF5ZXJJbmRleGVzRGlpAAEAAAABAAAAAHMADkN1c3RvbVByb3BlcnR5cwAKSXQncyBWYWx1ZQ=="
    },
    "CheckUserOnJoin": false,
    "CustomProperties": {

    },
    "DeleteCacheOnLeave": true,
    "EmptyRoomTTL": 0,
    "IsOpen": true,
    "IsVisible": true,
    "LobbyType": 0,
    "LobbyProperties": [

    ],
    "MaxPlayers": 4,
    "PlayerTTL": 0,
    "SuppressRoomEvents": false,
    "Slice": 0,
    "DebugInfo": {
      "DEBUG_PROPERTIES_18": {
        "250": [

        ],
        "PlayerIndexes": {
          "1": 0
        },
        "CustomProperty": "It's Value"
      }
    },
    "ExcludedActors": [

    ],
    "PublishUserId": false,
    "ExpectedUsers": [

    ]
  },
  "Type": "Game",
  "UserId": "834D5AA5BAB1DFB6",
  "Username": ""
}

Beim Ändern benutzerdefinierter Raumeigenschaften mithilfe des Unity Photon-Clients ist es wichtig, den Aufruf zu markieren, damit er das Ereignis an Webhook übergibt (in diesem Fall PlayFab).

// Properties updates ( this hashtable contains the properties to be changed. Properties not mentioned here will stay as is
var properties = new ExitGames.Client.Photon.Hashtable() { { "CustomProperty" , "It's Value" } };

// Control set. Empty in this case, because our property has not existed before.
// Otherwise you would include previous value of the property.
var expectedProperties = new ExitGames.Client.Photon.Hashtable();

// Set Custom Properties call. Notice the last argument set to "true"
// This tells Photon to forward event to the webhook.
PhotonNetwork.room.SetCustomProperties(properties, expectedProperties, true);

Raumereignis ausgelöst

Das ausgelöste Raumereignis wird jedes Mal aufgerufen, wenn ein benutzerdefiniertes Raumereignis ausgelöst wird. Der folgende CloudScript-Handler fängt ein solches Ereignis ab.

// Triggered by calling "OpRaiseEvent" on the Photon client. The "args.Data" property is
// set to the value of the "customEventContent" HashTable parameter, so you can use
// it to pass in arbitrary data.
handlers.RoomEventRaised= function (args) {
    return { ResultCode : 0, Message: 'Success' };
};

Sie können weitere Daten über das Ereignis mit dem Argument "args" abrufen.

{
  "ActorNr": 1,
  "AppVersion": "1.2_1.85",
  "AppId": "bfd5f98b-c6a4-4763-80d9-824d20db842b",
  // Custom event data
  "Data": {
    "Hello": "World"
  },
  "GameId": "8b8322de-096d-4481-a2b2-8db8bb45cfef",
  "Region": "EU",
  "State": {
    "ActorCounter": 1,
    "ActorList": [
      {
        "ActorNr": 1,
        "UserId": "834D5AA5BAB1DFB6",
        "Username": "",
        "IsActive": true,
        "Binary": "RGIAAAEBRAAAAAFi\/3MAAA==",
        "DEBUG_BINARY": {
          "1": {
            "255": ""
          }
        }
      }
    ],
    "Binary": {
      "18": "RAAAAAJi+nkAAHNzAA1QbGF5ZXJJbmRleGVzRGlpAAEAAAABAAAAAA=="
    },
    "CheckUserOnJoin": false,
    "CustomProperties": {

    },
    "DeleteCacheOnLeave": true,
    "EmptyRoomTTL": 0,
    "IsOpen": true,
    "IsVisible": true,
    "LobbyType": 0,
    "LobbyProperties": [

    ],
    "MaxPlayers": 4,
    "PlayerTTL": 0,
    "SuppressRoomEvents": false,
    "Slice": 0,
    "DebugInfo": {
      "DEBUG_PROPERTIES_18": {
        "250": [

        ],
        "PlayerIndexes": {
          "1": 0
        }
      }
    },
    "ExcludedActors": [

    ],
    "PublishUserId": false,
    "ExpectedUsers": [

    ]
  },
  "Type": "Event",
  // PlayFab User Id if he/she was the source of the event
  "UserId": "834D5AA5BAB1DFB6",
  "Username": "",
  // Event code
  "EvCode": 15
}

Beim Auslösen von benutzerdefinierten Raumereignissen mit dem Unity Photon-Client ist es wichtig, den Aufruf so zu markieren, dass er das Ereignis an Webhooks übergibt (in diesem Fall PlayFab).

var data = new Dictionary<string,object>() {
    { "Hello" , "World" }
};

// Raise custom room event
// Replace 15 with any custom event code of your choice [0..299]
PhotonNetwork.RaiseEvent(15, data, true, new RaiseEventOptions() {
    ForwardToWebhook = true, // Mark call to pass event to Webhook (PlayFab in this case)
});

Testraum-Ereignishandler

In diesem Beispiel wird das vorherige Beispiel (PlayFab + Photon-Authentifizierung) erweitert.

Laden Sie den folgenden CloudScript-Code für Ihren Titel hoch.

handlers.RoomCreated = function (args) {
    server.WriteTitleEvent({
        EventName : "room_created"
    });
    return { ResultCode : 0, Message: 'Success' };
};

handlers.RoomJoined = function (args) {
    server.WriteTitleEvent({
        EventName : "room_joined"
    });
    return { ResultCode : 0, Message: 'Success' };
};

handlers.RoomLeft = function (args) {
    server.WriteTitleEvent({
        EventName : "room_left"
    });
    return { ResultCode : 0, Message: 'Success' };
};

handlers.RoomClosed = function (args) {
    server.WriteTitleEvent({
        EventName : "room_closed"
    });
    return { ResultCode : 0, Message: 'Success' };
};

handlers.RoomPropertyUpdated = function (args) {
    server.WriteTitleEvent({
        EventName : "room_property_changed"
    });
    return { ResultCode : 0, Message: 'Success' };
};

handlers.RoomEventRaised = function (args) {
    server.WriteTitleEvent({
        EventName : "room_event_raised"
    });
    return { ResultCode : 0, Message: 'Success' };
};

Der Code stellt nur ein neues Titelereignis bereit, wenn ein Photon-Rückruf aufgerufen wird. Da dieses Beispiel in der Produktion nicht von Nutzen ist, können wir deutlich sehen, wie die Rückrufe aufgerufen werden.

Erweitern Sie das PlayFabAuthenticator Skript, indem Sie neuen Beispielcode einschließen, der ein benutzerdefiniertes Ereignis auslöst, und legen Sie die benutzerdefinierte Raumeigenschaft fest. Die erweiterte Version verwendet auch eine Awake -Methode, um ein Objekt zwischen Szenenladevorgängen nicht zu zerstören.

using System.Collections.Generic;
using PlayFab;
using PlayFab.ClientModels;
using UnityEngine;

public class PlayFabAuthenticator : MonoBehaviour {

    private string _playFabPlayerIdCache;


    //Run the entire thing on awake
    public void Awake() {
        AuthenticateWithPlayFab();
        DontDestroyOnLoad(gameObject);
    }


    /*
     * Step 1
     * We authenticate a current PlayFab user normally.
     * In this case we use the LoginWithCustomID API call for simplicity.
     * You can absolutely use any Login method you want.
     * We use PlayFabSettings.DeviceUniqueIdentifier as our custom ID.
     * We pass RequestPhotonToken as a callback to be our next step, if
     * authentication was successful.
     */
    private void AuthenticateWithPlayFab()  {
        LogMessage("PlayFab authenticating using Custom ID...");

        PlayFabClientAPI.LoginWithCustomID(new LoginWithCustomIDRequest()
        {
            CreateAccount = true,
            CustomId = PlayFabSettings.DeviceUniqueIdentifier+"EDITOR"
        }, RequestPhotonToken, OnPlayFabError);
    }

    /*
    * Step 2
    * We request a Photon authentication token from PlayFab.
    * This is a crucial step, because Photon uses different authentication tokens
    * than PlayFab. Thus, you cannot directly use PlayFab SessionTicket and
    * you need to explicitly request a token. This API call requires you to
    * pass a Photon App ID. The App ID may be hard coded, but in this example,
    * we are accessing it using convenient static field on PhotonNetwork class.
    * We pass in AuthenticateWithPhoton as a callback to be our next step, if
    * we have acquired the token successfully.
    */
    private void RequestPhotonToken(LoginResult obj) {
        LogMessage("PlayFab authenticated. Requesting photon token...");

        //We can player PlayFabId. This will come in handy during next step
        _playFabPlayerIdCache = obj.PlayFabId;

        PlayFabClientAPI.GetPhotonAuthenticationToken(new GetPhotonAuthenticationTokenRequest()
        {
            PhotonApplicationId = PhotonNetwork.PhotonServerSettings.AppSettings.AppIdRealtime
        }, AuthenticateWithPhoton, OnPlayFabError);
    }

    /*
     * Step 3
     * This is the final and the simplest step. We create a new AuthenticationValues instance.
     * This class describes how to authenticate a player inside the Photon environment.
     */
    private void AuthenticateWithPhoton(GetPhotonAuthenticationTokenResult obj) {
        LogMessage("Photon token acquired: " + obj.PhotonCustomAuthenticationToken + "  Authentication complete.");

        //We set AuthType to custom, meaning we bring our own, PlayFab authentication procedure.
        var customAuth = new Photon.Realtime.AuthenticationValues { AuthType = CustomAuthenticationType.Custom };

        //We add "username" parameter. Do not let it confuse you: PlayFab is expecting this parameter to contain player PlayFab ID (!) and not username.
        customAuth.AddAuthParameter("username", _playFabPlayerIdCache);    // expected by PlayFab custom auth service

        //We add "token" parameter. PlayFab expects it to contain Photon Authentication Token issues to your during previous step.
        customAuth.AddAuthParameter("token", obj.PhotonCustomAuthenticationToken);

        //We finally tell Photon to use this authentication parameters throughout the entire application.
        PhotonNetwork.AuthValues = customAuth;
    }

    private void OnPlayFabError(PlayFabError obj) {
        LogMessage(obj.ErrorMessage);
    }

    public void LogMessage(string message) {
        Debug.Log("PlayFab + Photon Example: " + message);
    }


    // Add small button to launch our example code
    public void OnGUI() {
        if (GUILayout.Button("Execute Example ")) ExecuteExample();
    }


    // Example code which raises custom room event, then sets custom room property
    private void ExecuteExample() {

        // Raise custom room event
        var data = new Dictionary<string, object>() { {"Hello","World"} };
        var result = PhotonNetwork.RaiseEvent(15, data, true, new RaiseEventOptions()
        {
            ForwardToWebhook = true,
        });
        LogMessage("New Room Event Post: "+result);

        // Set custom room property
        var properties = new ExitGames.Client.Photon.Hashtable() { { "CustomProperty", "It's Value" } };
        var expectedProperties = new ExitGames.Client.Photon.Hashtable();
        PhotonNetwork.room.SetCustomProperties(properties, expectedProperties, true);
        LogMessage("New Room Properties Set");
    }

}
  • Führen Sie die Hubszene aus, und warten Sie, bis die PlayFab-Authentifizierung abgeschlossen ist (1).
  • Laden Sie dann die Boxen-Demoszene(2).

Szene zum Laden von Demoboxen

  • Warten Sie nach dem Laden der Szene, bis der Peer eine Verbindung mit dem neu erstellten Raum (1) herstellt.
  • Wählen Sie dann in der oberen linken Ecke (2)Execute Example (Execute Example) (Beispiel ausführen) aus.
  • Beobachten Sie die Konsolenausgabe (3).
  • Stellen Sie sicher, dass keine Fehler aufgetreten sind.

Beispiel ausführen

Vergessen Sie nicht, Unity am Spielen zu hindern. Dies geschieht, um sicherzustellen, dass wir auch RoomLeft - und RoomClosed-Ereignisse erhalten.

Navigieren Sie zur Titelseite Game Manager, und beobachten Sie den PlayStream-Bereich . Sie sollten Ereignisse sehen können, die als Ergebnis unseres CloudScript-Codes generiert wurden, der Photon-Ereignisse behandelt.

  1. Zunächst hatte unser Photon instance keinen geöffneten Raum. Als wir das Beispiel gestartet haben, hat Photon den Raum für die Boxen-Demo erstellt.
  2. Der erste Spieler, der beitritt, ist der Spieler, der den Raum angefordert hat. Es wurde also kein RoomJoined-Ereignis aufgezeichnet. Anschließend haben wir unseren Beispielcode ausgeführt:
    • Zuerst haben wir ein benutzerdefiniertes Raumereignis ausgelöst.
    • Anschließend legen wir eine benutzerdefinierte Raumeigenschaft fest.
    • Anschließend haben wir den Unity-Wiedergabemodus beendet. Dies führte dazu, dass unser Mandant den Raum verließ.
  3. Da unser getrennter Client der letzte war, gibt es keine Clients mehr und Photon schließt den Raum.

Alle Ereignisse sollten im PlayStream-Ereignisfluss protokolliert werden, wie in der folgenden Abbildung dargestellt.

PlayStream-Ereignisfluss

An diesem Punkt haben Sie die Photon-Ereignisunterstützung vollständig in Ihren PlayFab-Titel integriert.