Freigeben über

Schnellstart: Lobby SDK

  • Artikel

In diesem Artikel wird beschrieben, wie Sie die Entwicklungsumgebung für Azure PlayFab Lobby einrichten und Ihren ersten Wartebereich mithilfe des PlayFab Multiplayer C/C++-SDK erstellen.

Notiz

Das PlayFab Multiplayer SDK bietet auch APIs für PlayFab Matchmaking.

Voraussetzungen

Sie benötigen ein PlayFab-Konto , um PlayFab Lobbies verwenden zu können. Anweisungen zum Erstellen eines Kontos finden Sie unter Schnellstart: Game Manager.

Herunterladen und Einrichten des PlayFab Multiplayer SDK

Laden Sie das C/C++-SDK für Ihre Plattform herunter, und integrieren Sie den Anbieterheader und die Bibliotheksdateien in Ihren Build.

Notiz

Dieser Schnellstart konzentriert sich auf die Verwendung des C/C++-SDK. Informationen zu Unity- und Unreal-Schnittstellen finden Sie in den folgenden Artikeln:

Anmelden bei einer PlayFab-Entität

Um das PlayFab Lobby SDK verwenden zu können, müssen Sie Ihren Client mithilfe von PlayFab-Entitätsschlüsseln und Entitätstoken authentifizieren. Rufen Sie einen PlayFab-Entitätsschlüssel und ein Tokenpaar ab, indem Sie sich mit der LoginWithCustomId-REST-API anmelden. Diese API ist auch als C/C++-Projektion über das PlayFab REST SDK verfügbar.

Notiz

LoginWithCustomId ist eine schnelle Möglichkeit für die ersten Schritte mit PlayFab-Features, ist jedoch nicht als Anmeldemechanismus gedacht, mit dem Sie ausgeliefert werden. Anleitungen zur Anmeldung finden Sie unter Grundlagen und bewährte Methoden für die Anmeldung.

Initialisieren des PlayFab Multiplayer SDK

Initialisieren Sie das PlayFab Multiplayer SDK, indem Sie die folgenden grundlegenden Schritte ausführen:

  1. Initialisieren des SDK durch Aufrufen von PFMultiplayerInitialize
  2. Legen Sie den Entitätsschlüssel und das Token fest, die von der Bibliothek im Namen Ihrer Spieler verwendet werden, indem Sie PFMultiplayerSetEntityToken aufrufen.
static PFMultiplayerHandle g_pfmHandle = nullptr;
...
...
HRESULT hr = S_OK;

// Initialize the PFMultiplayer library.
hr = PFMultiplayerInitialize(titleId, &g_pfmHandle);
if (FAILED(hr))
{
    // handle initialize failure
    printf("PFMultiplayerInitialize failed! %s\n", PFMultiplayerGetErrorMessage(hr));
    return hr;
}

// Set an entity token for a local user. The token is used to authenticate PlayFab operations on behalf of this user. 
// Tokens can expire, and this API token should be called again when this token is refreshed.
hr = PFMultiplayerSetEntityToken(g_pfmHandle, localUserEntity, entityToken);
if (FAILED(hr))
{
    // handle set entity token failure
    printf("PFMultiplayerSetEntityToken failed! %s\n", PFMultiplayerGetErrorMessage(hr));
    return hr;
}

Erstellen eines Wartebereichs

Abschließend erstellen wir einen Wartebereich, indem wir die folgenden grundlegenden Schritte ausführen:

  1. PfMultiplayerCreateAndJoinLobby aufrufen
  2. Überprüfen Sie die asynchrone Vervollständigung, indem Sie in regelmäßigen Abständen PFMultiplayerStartProcessingLobbyStateChanges für eine PFLobbyCreateAndJoinLobbyCompletedStateChange abfragen.
PFLobbyCreateConfiguration lobbyConfiguration{};
lobbyConfiguration.maxMemberCount = 16;
lobbyConfiguration.ownerMigrationPolicy = PFLobbyOwnerMigrationPolicy::Automatic;
lobbyConfiguration.accessPolicy = PFLobbyAccessPolicy::Public;

PFLobbyJoinConfiguration memberConfiguration{};

PFLobbyHandle lobby;
HRESULT hr = PFMultiplayerCreateAndJoinLobby(g_pfmHandle, localUserEntity, &lobbyConfiguration, &memberConfiguration, nullptr, &lobby);
if (FAILED(hr))
{
    // handle immediate create failure
    printf("PFMultiplayerCreateAndJoinLobby failed! %s\n", PFMultiplayerGetErrorMessage(hr));
    return hr;
}

// NOTE: to simplify this quickstart, we'll synchronously block waiting waiting for the CreateAndJoinLobby operation
// to finish. In a real implementation, this polling would be done asynchronously on a background thread/worker.
bool createAndJoinLobbyFinished = false;
while (!createAndJoinLobbyFinished)
{
    uint32_t lobbyStateChangeCount;
    const PFLobbyStateChange * const * lobbyStateChanges;
    HRESULT hr = PFMultiplayerStartProcessingLobbyStateChanges(m_pfmHandle, &lobbyStateChangeCount, &lobbyStateChanges);
    if (FAILED(hr))
    {
        // handle the failure
        printf("PFMultiplayerStartProcessingLobbyStateChanges failed! %s\n", PFMultiplayerGetErrorMessage(hr));
        return hr;
    }

    for (uint32_t i = 0; i < lobbyStateChangeCount; ++i)
    {
        const PFLobbyStateChange* stateChange = lobbyStateChanges[i];
        switch (stateChange->stateChangeType)
        {
            case PFLobbyStateChangeType::CreateAndJoinLobbyCompleted:
            {
                auto createAndJoinStateChange = 
                    static_cast<const PFLobbyCreateAndJoinLobbyCompletedStateChange*>(stateChange);

                if (SUCCEEDED(createAndJoinStateChange->result))
                {
                    // lobby successfully created!
                    printf("Lobby 0x%p successfully created!\n", createAndJoinStateChange->lobby);
                }
                else
                {
                    // report asynchronous failure
                    printf("Failed to create lobby 0x%p! %s\n",
                        createAndJoinStateChange->lobby,
                        PFMultiplayerGetErrorMessage(createAndJoinStateChange->result));
                }
                createAndJoinLobbyFinished = true;
                break;
            }
        }
    }

    hr = PFMultiplayerFinishProcessingLobbyStateChanges(m_pfmHandle, lobbyStateChangeCount, lobbyStateChanges);
    if (FAILED(hr))
    {
        printf("PFMultiplayerFinishProcessingLobbyStateChanges failed! %s\n", PFMultiplayerGetErrorMessage(hr));
        return hr;
    }
}

Weitere Informationen zum Erstellen von Lobbies finden Sie unter Erstellen einer Lobby.

Weitere Informationen zur Verarbeitung asynchroner Vorgänge finden Sie unter Asynchrone Vorgänge und Benachrichtigungen.

Nächste Schritte

Weitere Informationen