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

# Démarrage rapide (Windows) - Party et Multiplayer

> Intégrez la voix, le clavardage et la mise en réseau de PlayFab Party avec le lobby et le matchmaking de PlayFab Multiplayer sous Windows à l'aide du SDK unifié PlayFab.

Ce guide vous montre comment intégrer PlayFab Party pour la voix, le clavardage et la mise en réseau de données, ainsi que PlayFab Multiplayer pour les services de lobby et de matchmaking, à l'aide du SDK unifié.

## Prérequis

Avant de commencer, assurez-vous d'avoir :

* Terminé la [configuration du SDK Core et l'authentification](/fr-CA/services/playfab/sdks/unified-sdk/quickstart-core)
* Un `PFEntityHandle` authentifié issu du processus de connexion
* Votre ID de titre PlayFab configuré dans Game Manager
* Une connaissance de base des modèles de programmation asynchrone

<Note>
  Ce guide suppose que vous avez déjà initialisé le SDK PlayFab et authentifié un joueur en suivant le [guide de démarrage rapide Core](/fr-CA/services/playfab/sdks/unified-sdk/quickstart-core). Si ce n'est pas le cas, suivez d'abord ce guide.
</Note>

## Ce que vous allez accomplir

À la fin de ce démarrage rapide, vous aurez :

* Initialisé PlayFab Party pour la mise en réseau et le clavardage
* Créé un utilisateur local et un contrôle de clavardage
* Configuré un réseau Party pour la communication
* Initialisé PlayFab Multiplayer et créé un lobby
* Compris les procédures de nettoyage des ressources Party et Multiplayer

## En-têtes et inclusions

### En-têtes requis

Incluez les en-têtes du SDK dans vos fichiers d'en-tête pour accéder aux fonctionnalités de PlayFab Party et Multiplayer :

```cpp theme={null}
#include <Party.h>
#include <Party_c.h>

#include <PFMultiplayer.h>
#include <PFLobby.h>

#include <playfab/services/PFServices.h>
```

### Fichiers d'implémentation

Incluez **PartyImpl.h** dans vos fichiers d'implémentation et utilisez l'espace de noms Party :

```cpp theme={null}
#include <PartyImpl.h>

using namespace Party;
```

## Étape 1 : initialiser PlayFab Party

Initialisez PlayFab Party en créant une référence singleton au `PartyManager` et en le configurant avec votre ID de titre et, éventuellement, des files d'attente de tâches pour un contrôle avancé des threads.

```cpp theme={null}
PartyManager& partyManager = PartyManager::GetSingleton();
PartyInitializationConfiguration partyInitConfig = {};
PartyError err;

partyInitConfig.titleId = (PartyString) m_titleId; // Your PlayFab Title ID
partyInitConfig.audioTaskQueue = nullptr; // Optional: Custom XTaskQueue for audio operations, or nullptr for default
partyInitConfig.networkingTaskQueue = nullptr; // Optional: Custom XTaskQueue for networking operations, or nullptr for default

err = partyManager.Initialize(&partyInitConfig);
if (PARTY_FAILED(err))
{
    std::wcerr << L"Failed to initialize PartyManager: 0x" << std::hex << err << std::endl;
    return err;
}

std::wcout << L"PartyManager initialized successfully" << std::endl;
```

<Tip>
  Les paramètres `audioTaskQueue` et `networkingTaskQueue` vous permettent de fournir des instances XTaskQueue personnalisées pour un contrôle précis des threads. Définissez-les sur `nullptr` pour utiliser le comportement de threading par défaut.
</Tip>

## Étape 2 : créer un utilisateur local

Créez un objet utilisateur local pour représenter le joueur authentifié sur l'appareil. Cet utilisateur est requis pour toutes les opérations de mise en réseau et de clavardage.

```cpp theme={null}
PartyLocalUser* localUser{};
PartyError userErr;

// Use the entityHandle obtained from authentication
userErr = partyManager.CreateLocalUser(entityHandle, &localUser);
if (PARTY_FAILED(userErr))
{
    std::wcerr << L"Failed to create local user: 0x" << std::hex << userErr << std::endl;
    return userErr;
}

std::wcout << L"Local user created successfully" << std::endl;
```

## Étape 3 : créer un contrôle de clavardage

Créez un contrôle de clavardage pour gérer les opérations de clavardage vocal et textuel de l'utilisateur sur cet appareil.

```cpp theme={null}
PartyLocalDevice* localDevice;
PartyError deviceErr = partyManager.GetLocalDevice(&localDevice);
if (PARTY_FAILED(deviceErr))
{
    std::wcerr << L"Failed to get local device: 0x" << std::hex << deviceErr << std::endl;
    return deviceErr;
}

PartyLocalChatControl* chatControl;
PartyError chatErr = localDevice->CreateChatControl(localUser, nullptr, nullptr, &chatControl);
if (PARTY_FAILED(chatErr))
{
    std::wcerr << L"Failed to create chat control: 0x" << std::hex << chatErr << std::endl;
    return chatErr;
}

std::wcout << L"Chat control created successfully" << std::endl;
```

Le contrôle de clavardage gère l'entrée et la sortie audio et active les fonctionnalités de communication vocale.

## Étape 4 : créer un réseau Party

Créez un réseau Party, c'est-à-dire un ensemble sécurisé d'appareils et d'utilisateurs qui peuvent échanger des messages de clavardage et des données. Un réseau Party correspond généralement au concept de session multijoueur ou de lobby de votre jeu.

```cpp theme={null}
PartyNetworkDescriptor networkDescriptor = {};
PartyNetworkConfiguration networkConfiguration = {};

// Configure network limits
networkConfiguration.directPeerConnectivityOptions = PartyDirectPeerConnectivityOptions::None;
networkConfiguration.maxDeviceCount = 8;
networkConfiguration.maxDevicesPerUserCount = 1;
networkConfiguration.maxEndpointsPerDeviceCount = 1;
networkConfiguration.maxUserCount = 8;
networkConfiguration.maxUsersPerDeviceCount = 1;

// Configure invitation settings
PartyInvitationConfiguration invitationConfiguration = {
    "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX", // Unique network identifier (generate a GUID)
    PartyInvitationRevocability::Anyone,
    0,
    nullptr
};

PartyError networkErr = partyManager.CreateNewNetwork(
    localUser,
    &networkConfiguration,
    0,
    nullptr,
    &invitationConfiguration,
    nullptr,
    &networkDescriptor,
    nullptr);

if (PARTY_FAILED(networkErr))
{
    std::wcerr << L"Failed to create Party network: 0x" << std::hex << networkErr << std::endl;
    return networkErr;
}

std::wcout << L"Party network created successfully" << std::endl;
```

<Info>
  Assurez-vous de fournir un identificateur de réseau (GUID) valide et unique dans `PartyInvitationConfiguration`. Cet ID est utilisé par les autres joueurs pour rejoindre votre réseau.
</Info>

🎉 **Félicitations!** Vous avez configuré avec succès la mise en réseau et le clavardage de PlayFab Party.

## Étape 5 : initialiser PlayFab Multiplayer

Initialisez le service PlayFab Multiplayer pour activer les fonctionnalités de lobby et de matchmaking.

```cpp theme={null}
PFMultiplayerHandle pfmHandle{};
MultiplayerInitializationConfiguration multiplayerInitConfig{};

multiplayerInitConfig.titleId = m_titleId; // Your PlayFab Title ID

HRESULT hr = PFMultiplayerInitialize(&multiplayerInitConfig, &pfmHandle);
if (FAILED(hr))
{
    std::wcerr << L"Failed to initialize Multiplayer: 0x" << std::hex << hr << std::endl;
    return hr;
}

std::wcout << L"PlayFab Multiplayer initialized successfully" << std::endl;
```

## Étape 6 : créer un lobby

Créez un lobby pour gérer les groupes de joueurs avant le début d'une partie. Les lobbies prennent en charge des fonctionnalités telles que la migration du propriétaire et le contrôle d'accès.

```cpp theme={null}
PFLobbyCreateConfiguration lobbyConfiguration{};
lobbyConfiguration.maxMemberCount = 8;
lobbyConfiguration.ownerMigrationPolicy = PFLobbyOwnerMigrationPolicy::Automatic;
lobbyConfiguration.accessPolicy = PFLobbyAccessPolicy::Private;

PFLobbyJoinConfiguration memberConfiguration{};

PFLobbyHandle lobby;
HRESULT hr = PFMultiplayerCreateAndJoinLobbyWithEntityHandle(
    pfmHandle,
    entityHandle,
    &lobbyConfiguration,
    &memberConfiguration,
    nullptr,
    &lobby);

if (FAILED(hr))
{
    std::wcerr << L"Failed to create and join lobby: 0x" << std::hex << hr << std::endl;
    return hr;
}

std::wcout << L"Lobby created and joined successfully" << std::endl;
```

🎉 **Excellent!** Vous avez maintenant configuré à la fois la mise en réseau Party et les services de lobby Multiplayer.

## Nettoyage des ressources

Lorsque votre jeu s'arrête ou que vous devez nettoyer les ressources PlayFab, effectuez le nettoyage dans le bon ordre :

```cpp theme={null}
// Clean up Party singleton
partyManager.Cleanup();

// Clean up Multiplayer handle
PFMultiplayerUninitialize(pfmHandle);

// Close entity handle
PFEntityCloseHandle(entityHandle);
entityHandle = nullptr;

// Close service config handle
PFServiceConfigCloseHandle(serviceConfigHandle);
serviceConfigHandle = nullptr;

// Uninitialize PlayFab Services
XAsyncBlock asyncBlock{};
HRESULT hr = PFServicesUninitializeAsync(&asyncBlock);
if (SUCCEEDED(hr))
{
    hr = XAsyncGetStatus(&asyncBlock, true); // Blocking wait for cleanup completion
}
```

<Info>
  Nettoyez toujours les ressources dans cet ordre : Party, Multiplayer, handles d'entité, configuration de service, puis PlayFab Services.
</Info>

## Étapes suivantes

Maintenant que vous avez configuré Party et Multiplayer, découvrez ces fonctionnalités supplémentaires :

### Fonctionnalités de mise en réseau Party

* **Clavardage vocal** : activez la communication vocale en temps réel avec l'intégration d'Azure Cognitive Services
* **Clavardage textuel** : implémentez la messagerie textuelle avec traduction et modération
* **Canaux de données** : envoyez des données de jeu personnalisées entre les joueurs
* **Gestion du réseau** : gérez les connexions et déconnexions des joueurs ainsi que les événements réseau

### Fonctionnalités de lobby Multiplayer

* **Intégration du matchmaking** : connectez les lobbies au matchmaking PlayFab
* **Propriétés du lobby** : stockez et synchronisez les paramètres et les métadonnées du jeu
* **Données des membres** : partagez des informations propres à chaque joueur au sein du lobby
* **Recherche et découverte** : trouvez et rejoignez des lobbies publics

### Concepts de base

* [Opérations asynchrones](/fr-CA/services/playfab/sdks/unified-sdk/async-model) : comprendre le modèle de programmation asynchrone de PlayFab
* [Gestion de la mémoire](/fr-CA/services/playfab/sdks/unified-sdk/memory-management) : pratiques exemplaires de gestion de la mémoire du SDK
* [Traçage et diagnostics](/fr-CA/services/playfab/sdks/unified-sdk/debug-trace) : déboguer et surveiller votre intégration

## Documentation de référence

* [Documentation du SDK PlayFab Party](/fr-CA/services/playfab/multiplayer/networking/party-sdks/overview)
* [Documentation du SDK PlayFab Multiplayer](/fr-CA/services/playfab/multiplayer/lobby/lobby-matchmaking-sdks/lobby-matchmaking-sdks)


## Related topics

- [Démarrage rapide de Party](/fr-CA/services/playfab/multiplayer/networking/quickstart.md)
- [Démarrage rapide du plugiciel Party pour Unity](/fr-CA/services/playfab/multiplayer/networking/party-unity-plugin-quickstart.md)
- [Démarrage rapide C++ pour Windows](/fr-CA/services/playfab/sdks/playfab-cpp/quickstart-windows.md)
- [Configuration du démarrage rapide du SDK unifié PlayFab](/fr-CA/services/playfab/sdks/unified-sdk/quickstart-setup.md)
- [Démarrage rapide GDK](/fr-CA/services/playfab/sdks/c/quickstart-gdk.md)