> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # Intégrer Party à Lobby à l'aide du SDK Multiplayer > Présentation pas à pas de la combinaison du SDK PlayFab Party et du SDK PlayFab Multiplayer afin que les joueurs d'un lobby partagent un même réseau de chat vocal et de données. PlayFab Lobby et PlayFab Party sont souvent utilisés ensemble pour créer et orchestrer des groupes de joueurs avant de les faire entrer dans une session en réseau. Cet article décrit comment utiliser les lobbies comme un mécanisme pratique pour partager des descripteurs de réseau Party, à l'aide de la bibliothèque Party C++ et de la bibliothèque Multiplayer C++. ## Configurer Party et le SDK Multiplayer Consultez les démarrages rapides de Party et de Lobby pour commencer. ### Party [Démarrage rapide de Party](/fr/services/playfab/multiplayer/networking/quickstart) ### Lobby [Démarrage rapide de Lobby](/fr/services/playfab/multiplayer/lobby/lobby-getting-started) ### Initialiser le SDK PlayFab Multiplayer Consultez le [Démarrage rapide de Lobby](/fr/services/playfab/multiplayer/lobby/lobby-getting-started#initialize-the-playfab-multiplayer-sdk) pour initialiser le SDK PlayFab Multiplayer. ### Créer un lobby avec une chaîne de descripteur de réseau sérialisée Créez un lobby et définissez le descripteur de réseau Party sous forme de texte dans les propriétés du lobby. Pour convertir le descripteur de réseau Party en chaîne de caractères, utilisez [PartyManager::SerializeNetworkDescriptor()](/fr/services/playfab/multiplayer/networking/reference/classes/PartyManager/methods/partymanager_serializenetworkdescriptor). Les définitions ci-dessous correspondent aux propriétés du lobby ainsi qu'aux clés et valeurs utilisées pour la recherche. ```cpp theme={null} const char* c_propertyKey_LobbyName{ "LobbyName" }; const char* c_propertyKey_PartyDescriptor{ "PartyDescriptor" }; const char* c_searchKey_LobbyGroup{ "string_key1" }; // For Key to identify lobby group const char* c_searchValue_LobbyGroup{ "PartySample" }; // Use a identifiable string for search lobby group // The reason for setting this value is to get the lobby name only from the search results, // and in practice, change it appropriately for the your game. const char* c_searchKey_LobbyName{ "string_key2" }; ``` 1. Appelez [PFMultiplayerCreateAndJoinLobby](/fr/services/playfab/multiplayer/lobby/playfabmultiplayerreference-cpp/pflobby/functions/pfmultiplayercreateandjoinlobby) 2. Vérifiez la fin de l'opération asynchrone en interrogeant périodiquement [PFMultiplayerStartProcessingLobbyStateChanges](/fr/services/playfab/multiplayer/lobby/playfabmultiplayerreference-cpp/pflobby/functions/pfmultiplayerstartprocessinglobbystatechanges) pour obtenir un [PFLobbyCreateAndJoinLobbyCompletedStateChange](/fr/services/playfab/multiplayer/lobby/playfabmultiplayerreference-cpp/pflobby/functions/pfmultiplayerstartprocessinglobbystatechanges). ```cpp theme={null} char descriptor[c_maxSerializedNetworkDescriptorStringLength + 1] = {}; // Serialize our local network descriptor for other peers to use PartyError err = PartyManager::SerializeNetworkDescriptor(&networkDescriptor, descriptor); if (PARTY_FAILED(err)) { // handle immediate create failure DEBUGLOG("SerializeNetworkDescriptor failed! %s\n", GetErrorMessage(err)); return false; } std::vector lobbyPropertyKeys; std::vector lobbyPropertyValues; lobbyPropertyKeys.push_back(c_propertyKey_LobbyName); lobbyPropertyValues.push_back(lobbyName); lobbyPropertyKeys.push_back(c_propertyKey_PartyDescriptor); lobbyPropertyValues.push_back(descriptor); std::vector searchPropertyKeys; std::vector searchPropertyValues; searchPropertyKeys.push_back(c_searchKey_LobbyGroup); searchPropertyValues.push_back(c_searchValue_LobbyGroup); searchPropertyKeys.push_back(c_searchKey_LobbyName); searchPropertyValues.push_back(lobbyName); PFLobbyCreateConfiguration lobbyConfiguration{}; lobbyConfiguration.maxMemberCount = 16; lobbyConfiguration.ownerMigrationPolicy = PFLobbyOwnerMigrationPolicy::Automatic; lobbyConfiguration.accessPolicy = PFLobbyAccessPolicy::Public; lobbyConfiguration.lobbyPropertyCount = static_cast(lobbyPropertyKeys.size()); lobbyConfiguration.lobbyPropertyKeys = lobbyPropertyKeys.data(); lobbyConfiguration.lobbyPropertyValues = lobbyPropertyValues.data(); lobbyConfiguration.searchPropertyCount = static_cast(searchPropertyKeys.size()); lobbyConfiguration.searchPropertyKeys = searchPropertyKeys.data(); lobbyConfiguration.searchPropertyValues = searchPropertyValues.data(); PFLobbyJoinConfiguration memberConfiguration{}; PFLobbyHandle lobby; HRESULT hr = PFMultiplayerCreateAndJoinLobby(m_pfmHandle, &userEntity, &lobbyConfiguration, &memberConfiguration, nullptr, &lobby); if (FAILED(hr)) { // handle immediate create failure DEBUGLOG("PFMultiplayerCreateAndJoinLobby failed! %s\n", PFMultiplayerGetErrorMessage(hr)); return false; } // NOTE: to simplify this quickstart, we'll synchronously block 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 DEBUGLOG("PFMultiplayerStartProcessingLobbyStateChanges failed! %s\n", PFMultiplayerGetErrorMessage(hr)); return false; } for (uint32_t i = 0; i < lobbyStateChangeCount; ++i) { const PFLobbyStateChange* stateChange = lobbyStateChanges[i]; switch (stateChange->stateChangeType) { case PFLobbyStateChangeType::CreateAndJoinLobbyCompleted: { auto createAndJoinStateChange = static_cast(stateChange); if (SUCCEEDED(createAndJoinStateChange->result)) { // lobby successfully created! DEBUGLOG("Lobby 0x%p successfully created!\n", createAndJoinStateChange->lobby); } createAndJoinLobbyFinished = true; break; } } } hr = PFMultiplayerFinishProcessingLobbyStateChanges(m_pfmHandle, lobbyStateChangeCount, lobbyStateChanges); if (FAILED(hr)) { DEBUGLOG("PFMultiplayerFinishProcessingLobbyStateChanges failed! %s\n", PFMultiplayerGetErrorMessage(hr)); return false; } } ``` ### Rechercher des lobbies Pour plus de détails sur l'utilisation de la recherche de lobbies, consultez le lien suivant : [Rechercher des lobbies](/fr/services/playfab/multiplayer/lobby/find-lobbies) Vous pouvez maintenant utiliser l'API Find Lobbies pour rechercher le lobby créé ci-dessus à l'aide de `c_searchValue_LobbyType` afin d'obtenir le descripteur de réseau sérialisé. 1. Appelez [PFMultiplayerFindLobbies](/fr/services/playfab/multiplayer/lobby/playfabmultiplayerreference-cpp/pflobby/functions/pfmultiplayerfindlobbies) ```cpp theme={null} std::string filterString; filterString.append(c_searchKey_LobbyGroup); filterString.append(" eq '"); filterString.append(c_searchValue_LobbyGroup); filterString.append("'"); PFLobbySearchConfiguration searchConfiguration = { 0 }; searchConfiguration.filterString = filterString.c_str(); HRESULT hr = PFMultiplayerFindLobbies(m_pfmHandle, &localUser, &searchConfiguration, nullptr); if (FAILED(hr)) { // handle immediate find lobbies failure printf("PFMultiplayerFindLobbies failed! %s\n", PFMultiplayerGetErrorMessage(hr)); return false; } // NOTE: to simplify this quickstart, we'll synchronously block waiting for the FindLobbies operation // to finish. In a real implementation, this polling would be done asynchronously on a background thread/worker. bool findLobbiesFinished = false; while (!findLobbiesFinished) { 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 false; } for (uint32_t i = 0; i < lobbyStateChangeCount; ++i) { const PFLobbyStateChange* stateChange = lobbyStateChanges[i]; switch (stateChange->stateChangeType) { case PFLobbyStateChangeType::FindLobbiesCompleted: { auto findLobbiesStateChange = static_cast(stateChange); if (FAILED(findLobbiesStateChange->result)) { printf("PFLobbyStateChangeType::FindLobbiesCompleted failed! %s\n", PFMultiplayerGetErrorMessage(findLobbiesStateChange->result)); break; } for (uint32_t i = 0; i < findLobbiesStateChange->searchResultCount; ++i) { const PFLobbySearchResult& searchResult = findLobbiesStateChange->searchResults[i]; // Use searchResult.connectionString for connecting a lobby later. MyGame::GuiPostLobbySearchResultRow(searchResult); // defined elsewhere } findLobbiesFinished = true; break; } } } hr = PFMultiplayerFinishProcessingLobbyStateChanges(m_pfmHandle, lobbyStateChangeCount, lobbyStateChanges); if (FAILED(hr)) { printf("PFMultiplayerFinishProcessingLobbyStateChanges failed! %s\n", PFMultiplayerGetErrorMessage(hr)); return false; } ``` ### Rejoindre un lobby Rejoignez maintenant le lobby obtenu lors de l'opération « Rechercher des lobbies » précédente à l'aide de la connectionString qui fait partie de PFLobbySearchResult. 1. Appelez [PFMultiplayerJoinLobby](/fr/services/playfab/multiplayer/lobby/playfabmultiplayerreference-cpp/pflobby/functions/pfmultiplayerjoinlobby) ```cpp theme={null} // Fill in the member properties of user for referencing in the game. const char* playerColorPropertyKey = "PlayerColor"; const char* playerColorPropertyValue = MyGame::GetPlayerColorString(localUser); std::vector memberPropertyKeys; std::vector memberPropertyValues; memberPropertyKeys.push_back(playerColorPropertyKey); memberPropertyValues.push_back(playerColorPropertyValue); PFLobbyJoinConfiguration joinConfig; joinConfig.memberPropertyCount = static_cast(memberPropertyKeys.size()); joinConfig.memberPropertyKeys = memberPropertyKeys.data(); joinConfig.memberPropertyValues = memberPropertyValues.data(); // Join the lobby using the connection string HRESULT hr = PFMultiplayerJoinLobby(m_pfmHandle, &localUser, connectionString, &joinConfig, nullptr, &m_lobby); if (FAILED(hr)) { // handle immediate join lobby failure DEBUGLOG("PFMultiplayerJoinLobby failed! %s\n", PFMultiplayerGetErrorMessage(hr)); return false; } // NOTE: to simplify this quickstart, we'll synchronously block waiting for the JoinLobby operation // to finish. In a real implementation, this polling would be done asynchronously on a background thread/worker. bool joinLobbyFinished = false; while (!joinLobbyFinished) { uint32_t lobbyStateChangeCount; const PFLobbyStateChange* const* lobbyStateChanges; HRESULT hr = PFMultiplayerStartProcessingLobbyStateChanges(m_pfmHandle, &lobbyStateChangeCount, &lobbyStateChanges); if (FAILED(hr)) { // handle the failure DEBUGLOG("PFMultiplayerStartProcessingLobbyStateChanges failed! %s\n", PFMultiplayerGetErrorMessage(hr)); return false; } for (uint32_t i = 0; i < lobbyStateChangeCount; ++i) { const PFLobbyStateChange* stateChange = lobbyStateChanges[i]; switch (stateChange->stateChangeType) { case PFLobbyStateChangeType::JoinLobbyCompleted: { auto joinStateChange = static_cast(stateChange); if (SUCCEEDED(joinStateChange->result)) { // lobby successfully joined! m_lobby = joinStateChange->lobby; uint32_t propertyCount; const char* const* keys; HRESULT hr = PFLobbyGetLobbyPropertyKeys(joinStateChange->lobby, &propertyCount, &keys); if (SUCCEEDED(hr)) { std::string descriptor; for (uint32_t idx = 0; idx < propertyCount; idx++) { const char* value; hr = PFLobbyGetLobbyProperty(joinStateChange->lobby, keys[idx], &value); if (SUCCEEDED(hr)) { if (strcmp(keys[idx], c_propertyKey_PartyDescriptor) == 0 && value) { descriptor = value; } } } if (!descriptor.empty()) { partyDescriptor = descriptor; } else { // report asynchronous failure DEBUGLOG("Failed to join lobby 0x%p! No Party descriptor found\n", joinStateChange->lobby); } } } joinLobbyFinished = true; break; } } } hr = PFMultiplayerFinishProcessingLobbyStateChanges(m_pfmHandle, lobbyStateChangeCount, lobbyStateChanges); if (FAILED(hr)) { DEBUGLOG("PFMultiplayerFinishProcessingLobbyStateChanges failed! %s\n", PFMultiplayerGetErrorMessage(hr)); return false; } } ``` ## Étapes suivantes Consultez [Démarrage rapide de Party : se connecter à un réseau Party](/fr/services/playfab/multiplayer/networking/quickstart#connect-to-a-party-network) pour vous connecter au réseau Party. ## Voir aussi ### SDK Party * [Fonctionnalités de Party](/fr/services/playfab/multiplayer/networking/party-features) * [SDK Party](/fr/services/playfab/multiplayer/networking/party-sdks/overview) * [Services multijoueurs](/fr/services/playfab/multiplayer/mpintro) * [Objets Party et leurs relations](/fr/services/playfab/multiplayer/networking/concepts-objects) * [Documentation de référence de l'API Party](/fr/services/playfab/multiplayer/networking/reference/party_members) ### SDK Multiplayer * [Référence du SDK Multiplayer](/fr/services/playfab/multiplayer/lobby/playfabmultiplayerreference-cpp/pflobby/pflobby_members) * [SDK Multiplayer](/fr/services/playfab/multiplayer/lobby/lobby-matchmaking-sdks/lobby-matchmaking-sdks) * [Créer un lobby](/fr/services/playfab/multiplayer/lobby/create-a-lobby) * [Opérations asynchrones et notifications](/fr/services/playfab/multiplayer/lobby/lobby-and-matchmaking-client-sdk-async) * [Créer des lobbies consultables](/fr/services/playfab/multiplayer/lobby/define-search-keywords) * [Propriétés du lobby](/fr/services/playfab/multiplayer/lobby/lobby-properties) ## Related topics - [Rechercher des lobbies](/fr/services/playfab/multiplayer/lobby/find-lobbies.md) - [Rejoindre des lobbies](/fr/services/playfab/multiplayer/lobby/join-lobbies.md) - [Créer un lobby](/fr/services/playfab/multiplayer/lobby/create-a-lobby.md) - [Démarrage rapide (Windows) - Party et Multiplayer](/fr/services/playfab/sdks/unified-sdk/quickstart-windows-party.md) - [Prise en main de Multiplayer sur Android](/fr/services/playfab/multiplayer/lobby/lobby-matchmaking-sdks/android-specific-requirements.md)