> ## 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.
# Tâches multijoueurs
> Exemples de code pour les tâches courantes de Multiplayer 2015 : abonnement aux modifications MPSD, création de sessions, envoi d'invitations, jonction, tickets de matchmaking et activité.
Cette rubrique décrit comment implémenter des tâches spécifiques liées à l'utilisation de Multiplayer 2015.
Cette rubrique couvre les points suivants :
* [S'abonner aux notifications de modification de session Multiplayer Session Directory (MPSD)](#sfmscn)
* [Créer une session MPSD](#cams)
* [Définir un arbitre pour une session MPSD](#set-an-arbiter-for-an-mpsd-session)
* [Gérer l'activation du titre](#mta)
* [Rendre l'utilisateur joignable](#mtuj)
* [Envoyer des invitations de jeu](#sgi)
* [Rejoindre une session de jeu à partir d'une session de lobby](#jagsfals)
* [Rejoindre une session MPSD à partir d'une activation de titre](#jamsfata)
* [Définir l'activité actuelle de l'utilisateur](#stuca)
* [Mettre à jour une session MPSD](#update-an-mpsd-session)
* [Quitter une session MPSD](#lams)
* [Remplir les emplacements de session libres pendant le matchmaking](#fossdm)
* [Créer un ticket de match](#camt)
* [Obtenir l'état d'un ticket de match](#gmts)
## S'abonner aux notifications de modification de session Multiplayer Session Directory (MPSD)
L'abonnement aux modifications d'une session exige que le joueur associé soit actif dans la session. Le champ `connectionRequiredForActiveMembers` doit également être défini sur `true` dans l'objet `/constants/system/capabilities` de la session. Ce champ est généralement défini dans le modèle de session. Pour plus d'informations, consultez [Modèles de session multijoueur](/fr-CA/services/xbox-services/multiplayer/mpsd/concepts/live-session-templates) et [Vue d'ensemble de Multiplayer Session Directory](/fr-CA/services/xbox-services/multiplayer/mpsd/live-mpsd-overview).
Pour recevoir les notifications de modification de session MPSD, le titre peut suivre la procédure suivante.
1. Utilisez le même objet `XblContextHandle` pour tous les appels d'un même utilisateur. Les abonnements sont liés à la durée de vie de cet objet. S'il y a plusieurs utilisateurs locaux, utilisez un objet `XblContextHandle` distinct pour chaque utilisateur.
2. Implémentez des gestionnaires d'événements pour [XblMultiplayerAddSessionChangedHandler](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayeraddsessionchangedhandler) et [XblMultiplayerSessionSubscriptionLostHandler](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessionsubscriptionlosthandler).
3. Si vous vous abonnez aux modifications pour plusieurs utilisateurs, ajoutez du code à votre gestionnaire d'événements `XblMultiplayerAddSessionChangedHandler` pour éviter un travail inutile. Utilisez la propriété [XblMultiplayerSessionChangeEventArgs](/fr-CA/reference/live/xsapi-c/multiplayer_c/structs/xblmultiplayersessionchangeeventargs)`::Branch` et la propriété [XblMultiplayerSessionChangeEventArgs](/fr-CA/reference/live/xsapi-c/multiplayer_c/structs/xblmultiplayersessionchangeeventargs)`::ChangeNumber`. Ces propriétés vous permettent de suivre la dernière modification vue et d'ignorer les modifications plus anciennes.
4. Appelez [XblMultiplayerSetSubscriptionsEnabled](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersetsubscriptionsenabled) pour autoriser les abonnements.
5. Créez un objet de session local, puis rejoignez cette session en tant que membre actif.
6. Appelez `XblMultiplayerAddSessionChangedHandler` pour chaque utilisateur, en transmettant le type de modification de session pour lequel vous souhaitez être notifié.
7. Écrivez la session dans MPSD comme décrit dans la section [Mettre à jour une session MPSD](#update-an-mpsd-session) de cette rubrique.
L'organigramme suivant montre comment démarrer le multijoueur en s'abonnant aux événements décrits dans la procédure précédente.
### Analyse des notifications de modification de session en double
Lorsque plusieurs utilisateurs sont abonnés aux notifications d'une même session, chaque modification de cette session déclenche un shoulder tap pour chaque utilisateur.
Tous ces shoulder taps, sauf un, sont des doublons.
Bien que nous recommandions toujours qu'un titre abonne chaque utilisateur d'une session aux notifications, un titre doit ignorer les modifications dont il a déjà été notifié. Vous pouvez le faire à l'aide des propriétés `Branch` et `ChangeNumber`.
Pour détecter les shoulder taps multiples, un titre doit procéder comme suit :
* Stocker la dernière valeur de la propriété `ChangeNumber` pour chaque valeur de la propriété `Branch` évaluée.
* Si un shoulder tap a une valeur de propriété `ChangeNumber` supérieure à la dernière valeur stockée pour cette valeur de propriété `Branch`, traiter le shoulder tap, puis mettre à jour la dernière valeur de la propriété `ChangeNumber`.
* Si un shoulder tap n'a pas de valeur de propriété `ChangeNumber` supérieure pour cette valeur de propriété `Branch`, ignorer le traitement du shoulder tap. Cette modification de session a déjà été traitée.
Les valeurs de la propriété `ChangeNumber` doivent être suivies par valeur de la propriété `Branch`, et non par session. La valeur de la propriété `Branch` peut changer au cours de la durée de vie d'une session, ce qui réinitialise la valeur de la propriété `ChangeNumber`.
[Retour en haut de cette rubrique.](#top)
## Créer une session MPSD
Par défaut, une session MPSD est créée lorsque le premier membre la rejoint. Si la logique de votre titre s'attend à ce que la session existe ou n'existe pas au moment de la jonction, elle peut transmettre une valeur de mode d'écriture appropriée à la méthode d'écriture lors de la mise à jour de la session.
Le titre doit procéder comme suit pour créer une nouvelle session.
1. Créez un nouvel objet `XblContextHandle`. Votre titre crée cet objet une seule fois, l'stocke et le réutilise selon les besoins dans tout le code source. Il est nécessaire d'utiliser exactement le même contexte, en particulier lorsque vous travaillez avec des abonnements de session.
2. Créez un nouveau `XblMultiplayerSessionHandle` avec [XblMultiplayerSessionCreateHandle](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessioncreatehandle) pour préparer toutes les données de session dont MPSD a besoin pour créer une nouvelle session.
3. Apportez les modifications requises avant d'écrire la session dans MPSD. Par exemple, lors de la jonction d'un membre à la session avec un appel à [XblMultiplayerSessionJoin](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessionjoin), le client ajoute des données de requête locales masquées qui indiquent à MPSD d'effectuer la jonction lors de l'appel de mise à jour de la session.
4. Lorsque vous avez terminé d'apporter des modifications locales, écrivez-les dans MPSD comme décrit dans la section [Mettre à jour une session MPSD](#update-an-mpsd-session) de cette rubrique.
5. Recevez de MPSD le nouvel objet `XblMultiplayerSessionHandle`, dont de nombreux champs sont renseignés.
6. Utilisez maintenant le nouvel objet de session. Supprimez l'ancienne copie, qui contient une requête masquée de création d'une nouvelle session.
### Exemple
**API C plate**
```cpp theme={null}
auto asyncBlock = std::make_unique();
asyncBlock->queue = queue;
asyncBlock->context = nullptr;
asyncBlock->callback = [](XAsyncBlock* asyncBlock)
{
std::unique_ptr asyncBlockPtr{ asyncBlock }; // Take over ownership of the XAsyncBlock*.
XblMultiplayerSessionHandle sessionHandle;
HRESULT hr = XblMultiplayerWriteSessionResult(asyncBlock, &sessionHandle);
if (SUCCEEDED(hr))
{
// Process multiplayer session handle.
}
else
{
// Handle failure.
}
};
XblMultiplayerSessionReference ref;
pal::strcpy(ref.Scid, sizeof(ref.Scid), SCID);
pal::strcpy(ref.SessionTemplateName, sizeof(ref.SessionTemplateName), SESSION_TEMPLATE_NAME);
pal::strcpy(ref.SessionName, sizeof(ref.SessionName), SESSION_NAME);
XblMultiplayerSessionInitArgs args = {};
XblMultiplayerSessionHandle sessionHandle = XblMultiplayerSessionCreateHandle(XUID, &ref, &args);
auto hr = XblMultiplayerSessionJoin(
sessionHandle,
memberCustomConstantsJson.c_str(),
initializeRequested,
joinWithActiveStatus);
hr = XblMultiplayerWriteSessionAsync(xblContextHandle, sessionHandle, XblMultiplayerSessionWriteMode::CreateNew, asyncBlock.get());
if (SUCCEEDED(hr))
{
// The call succeeded, so release the std::unique_ptr ownership of XAsyncBlock* because the callback will take over ownership.
// If the call fails, std::unique_ptr will keep ownership and delete XAsyncBlock*.
asyncBlock.release();
}
```
Pour plus d'informations, consultez les rubriques suivantes :
* [XAsyncBlock](/fr-CA/reference/system/xasync/structs/xasyncblock)
* [XblMultiplayerSessionCreateHandle](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessioncreatehandle)
* [XblMultiplayerSessionInitArgs](/fr-CA/reference/live/xsapi-c/multiplayer_c/structs/xblmultiplayersessioninitargs)
* [XblMultiplayerSessionReference](/fr-CA/reference/live/xsapi-c/multiplayer_c/structs/xblmultiplayersessionreference)
* [XblMultiplayerSessionWriteMode](/fr-CA/reference/live/xsapi-c/multiplayer_c/enums/xblmultiplayersessionwritemode)
* [XblMultiplayerWriteSessionAsync](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayerwritesessionasync)
* [XblMultiplayerWriteSessionResult](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayerwritesessionresult)
[Retour en haut de cette rubrique.](#top)
## Définir un arbitre pour une session MPSD
Le titre suit la procédure suivante pour définir un arbitre pour une session déjà créée.
Les jetons d'appareil des membres (hôtes potentiels) ne sont disponibles qu'une fois que les membres ont rejoint la session et inclus leurs adresses d'appareil sécurisées.
1. Récupérez auprès de MPSD les jetons d'appareil des candidats hôtes en appelant [XblMultiplayerSessionMembers](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessionmembers).
> \[!NOTE]
> Si la session a été créée par le matchmaking SmartMatch, vos clients peuvent utiliser les candidats hôtes disponibles auprès de MPSD en appelant [XblMultiplayerSessionHostCandidates](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessionhostcandidates).
2. Sélectionnez l'hôte souhaité dans la liste des candidats hôtes.
3. Appelez [XblMultiplayerSessionSetHostDeviceToken](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessionsethostdevicetoken) pour définir le jeton d'appareil dans le cache local de MPSD. Si l'appel de définition du jeton d'appareil hôte réussit, le jeton d'appareil local remplace le jeton de l'hôte.
4. Si un code d'état HTTP/412 est reçu lors de la tentative de définition du jeton d'appareil hôte, interrogez les données de session. Vérifiez si le jeton d'appareil hôte correspond à la console locale. Si ce n'est pas le cas, une autre console a été désignée comme arbitre.
> \[!NOTE]
> Votre client doit gérer le code d'état HTTP/412 séparément des autres codes HTTP, car HTTP/412 n'indique pas un échec standard. Pour plus d'informations sur ce code d'état, consultez [Codes d'état des sessions multijoueurs](/fr-CA/services/xbox-services/multiplayer/mpsd/how-to/live-mpsd-status-codes).
5. Mettez à jour la session dans MPSD comme décrit dans la section [Mettre à jour une session MPSD](#update-an-mpsd-session) de cette rubrique.
> \[!NOTE]
> Si vous ne disposez pas d'un meilleur algorithme, le client peut implémenter un algorithme glouton dans lequel chaque candidat hôte tente de se définir comme hôte si personne d'autre ne l'a encore fait. Pour plus d'informations, consultez la section [Arbitre de session](/fr-CA/services/xbox-services/multiplayer/mpsd/concepts/live-mpsd-details#session-arbiter) de la rubrique Rubriques avancées sur les sessions multijoueurs.
[Retour en haut de cette rubrique.](#top)
## Gérer l'activation du titre
XBOX One (ou version ultérieure) déclenche l'événement `CoreApplicationView.Activated` lors de l'activation par protocole.
Dans le contexte de l'API multijoueur, cet événement est déclenché lorsqu'un utilisateur accepte une invitation ou rejoint un autre utilisateur.
Ces actions déclenchent une activation à laquelle le titre doit réagir en faisant entrer l'utilisateur qui rejoint dans le jeu avec l'utilisateur cible.
Votre titre doit s'attendre à recevoir de nouveaux arguments d'activation à tout moment et ne doit jamais être codé en fonction de leur longueur.
Le titre doit effectuer les principales étapes suivantes pour gérer l'activation du titre.
1. Configurez un gestionnaire d'événements pour l'événement `CoreApplicationView.Activated`. Ce gestionnaire se déclenche à chaque activation par protocole, même si le titre est déjà en cours d'exécution.
2. Lors de l'activation du titre, démarrez une session et abonnez-vous aux notifications de modification de session. Pour plus d'informations, consultez [S'abonner aux notifications de modification de session MPSD](#sfmscn) dans cette rubrique.
3. Faites rejoindre la session à l'utilisateur en tant que membre actif. Pour plus d'informations, consultez [Rejoindre une session MPSD à partir d'une activation de titre](#jamsfata) dans cette rubrique.
4. Définissez la session de lobby comme session d'activité exposée au moyen de l'interface utilisateur du profil. Pour plus d'informations, consultez [Définir l'activité actuelle de l'utilisateur](#stuca) dans cette rubrique.
5. Faites rejoindre la session de jeu à l'utilisateur en tant que membre actif. L'utilisateur peut maintenant se connecter aux pairs et entrer dans le jeu ou dans le lobby.
L'organigramme suivant montre comment gérer l'activation du titre.
[Retour en haut de cette rubrique.](#top)
## Rendre l'utilisateur joignable
Pour rendre l'utilisateur joignable, le titre doit procéder comme suit :
1. Créez un objet de session, puis modifiez les attributs selon les besoins.
2. Faites rejoindre la session à l'utilisateur en tant que membre actif. Pour plus d'informations, consultez [Rejoindre une session MPSD à partir d'une activation de titre](#jamsfata) dans cette rubrique.
3. Déterminez si l'utilisateur a été désigné comme arbitre de la session.
4. Si l'utilisateur n'est pas l'arbitre, passez à l'étape 7.
5. Si l'utilisateur est l'arbitre, appelez [XblMultiplayerSessionSetHostDeviceToken](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessionsethostdevicetoken).
6. Tentez d'écrire la session en appelant [XblMultiplayerWriteSessionAsync](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayerwritesessionasync).
7. Définissez la session comme session active. Pour plus d'informations, consultez [Définir l'activité actuelle de l'utilisateur](#stuca) dans cette rubrique.
L'organigramme suivant montre les étapes permettant à un utilisateur d'être rejoint par d'autres joueurs pendant une partie.
[Retour en haut de cette rubrique.](#top)
## Envoyer des invitations de jeu
Le titre peut permettre à un joueur d'envoyer des invitations de jeu des manières suivantes.
* Envoyer les invitations pour la session de lobby.
* Envoyer les invitations à l'aide de l'interface utilisateur d'invitation générique de la plateforme XBOX, avec la référence de la session de jeu.
Pour envoyer des invitations de jeu pour un joueur, le titre doit procéder comme suit :
1. Rendre la partie du joueur qui invite joignable. Pour plus d'informations, consultez [Rendre l'utilisateur joignable](#mtuj) dans cette rubrique.
2. Déterminer si les invitations doivent être envoyées au moyen de la session de lobby ou à l'aide de l'interface utilisateur d'invitation.
3. Si la session de lobby est utilisée, envoyer les invitations en appelant [XblMultiplayerSendInvitesAsync](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersendinvitesasync). Cette méthode peut nécessiter la création d'une liste de joueurs dans l'interface du jeu en appelant [XGameUiShowPlayerPickerAsync](/fr-CA/reference/system/xgameui/functions/xgameuishowplayerpickerasync).
4. Si l'interface utilisateur d'invitation est utilisée, appeler [XGameUiShowSendGameInviteAsync](/fr-CA/reference/system/xgameui/functions/xgameuishowsendgameinviteasync) pour afficher l'interface utilisateur d'invitation.
5. Gérer [XblMultiplayerAddSessionChangedHandler](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayeraddsessionchangedhandler) pour le joueur local une fois que le joueur distant a rejoint la session.
6. Pour le joueur distant, implémenter un code d'activation de titre. Pour plus d'informations, consultez [Gérer l'activation du titre](#mta) dans cette rubrique.
L'organigramme suivant montre comment envoyer des invitations.
[Retour en haut de cette rubrique.](#top)
## Rejoindre une session de jeu à partir d'une session de lobby
Les sessions de jeu sur les appareils Windows 10 doivent avoir la fonctionnalité `userAuthorizationStyle` définie sur `true` s'il ne s'agit pas de grandes sessions. Par conséquent, la propriété `joinRestriction` ne peut pas être `none`, ce qui signifie que la session ne peut pas être directement joignable publiquement.
Un scénario courant consiste à créer une session de lobby pour rassembler des joueurs, puis à déplacer ces joueurs vers une session de jeu ou une session de matchmaking. Mais si la session de jeu n'est pas joignable publiquement, les clients du jeu ne peuvent pas la rejoindre, sauf s'ils respectent le paramètre `joinRestriction`. Dans la plupart des cas, ce paramètre est trop restrictif pour ce scénario.
La solution consiste à utiliser un handle de transfert pour lier la session de lobby et la session de jeu. Le titre peut procéder comme suit :
1. Lorsque vous créez la session de jeu, utilisez l'API [XblMultiplayerSetTransferHandleAsync](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersettransferhandleasync) pour créer un handle de transfert qui lie la session de lobby et la session de jeu.
2. Stockez le GUID du handle de transfert dans la session de lobby au lieu de la référence de la session de jeu.
3. Lorsque le titre souhaite déplacer des membres de la session de lobby vers la session de jeu, chaque client utilise le handle de transfert de la session de lobby pour rejoindre la session de jeu à l'aide de l'API [XblMultiplayerWriteSessionByHandleAsync](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayerwritesessionbyhandleasync).
4. MPSD consulte la session de lobby pour vérifier que les membres qui tentent de rejoindre la session de jeu à l'aide du handle de transfert se trouvent également dans la session de lobby.
5. Si les membres se trouvent dans la session de lobby, ils peuvent accéder à la session de jeu.
[Retour en haut de cette rubrique.](#top)
## Rejoindre une session MPSD à partir d'une activation de titre
Lorsqu'un utilisateur choisit de rejoindre l'activité d'un ami ou d'accepter une invitation à l'aide de l'interface utilisateur du shell XBOX, le titre est activé avec des paramètres qui indiquent quelle session l'utilisateur souhaite rejoindre. Le titre doit gérer cette activation et ajouter l'utilisateur à la session correspondante.
Voici les étapes que le titre doit suivre.
1. Implémentez un gestionnaire d'événements pour l'événement `CoreApplicationView.Activated`. Il signale les activations du titre.
2. Lorsque le gestionnaire se déclenche, examinez la propriété `IActivatedEventArgs.Kind`. Si elle est définie sur `Protocol`, effectuez un cast des arguments de l'événement vers la classe `ProtocolActivatedEventArgs`.
3. Examinez l'objet `ProtocolActivatedEventArgs`. Si l'URI indiqué dans la propriété `ProtocolActivatedEventArgs.Uri` correspond à `inviteHandleAccept` (invitation acceptée) ou à `activityHandleJoin` (jonction au moyen de l'interface utilisateur du shell), analysez la chaîne de requête de l'URI. Elle est mise en forme comme une chaîne de requête d'URI normale avec des paires clé/valeur; extrayez les champs suivants.
* Pour une invitation acceptée :
1. `handle`
2. `invitedXuid`
3. `senderXuid`
* Pour une jonction :
1. `handle`
2. `joinerXuid`
3. `joineeXuid`
4. Démarrez le code multijoueur du titre, qui doit inclure un appel à [XblMultiplayerSetSubscriptionsEnabled](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersetsubscriptionsenabled).
5. Créez un objet `XblMultiplayerSessionHandle` local en appelant [XblMultiplayerSessionCreateHandle](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessioncreatehandle).
6. Appelez [XblMultiplayerSessionJoin](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessionjoin) pour rejoindre la session. Utilisez les paramètres suivants afin que la jonction soit définie comme active.
* `memberCustomConstantsJson` = `null`
* `initializeRequested` = `false`
* `joinWithActiveStatus` = `true`
7. Appelez [XblMultiplayerSessionSetSessionChangeSubscription](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessionsetsessionchangesubscription) pour recevoir un shoulder tap lorsque la session change après la jonction.
8. Appelez [XblMultiplayerWriteSessionByHandleAsync](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayerwritesessionbyhandleasync) en utilisant le handle obtenu comme décrit à l'étape 3. L'utilisateur est maintenant membre de la session et peut utiliser les données de la session pour se connecter au jeu.
[Retour en haut de cette rubrique.](#top)
## Définir l'activité actuelle de l'utilisateur
L'activité actuelle de l'utilisateur est affichée dans les expériences utilisateur du tableau de bord XBOX pour le titre. L'activité d'un utilisateur peut être définie au moyen d'une session ou au moyen de l'activation du titre. Dans ce dernier cas, l'utilisateur entre dans une session au moyen du matchmaking ou en démarrant une partie.
L'activité définie au moyen d'une session peut être supprimée en appelant [XblMultiplayerClearActivityAsync](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayerclearactivityasync).
Pour définir une session comme activité actuelle de l'utilisateur, le titre appelle [XblMultiplayerSetActivityAsync](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersetactivityasync). Il transmet la référence de la session.
Pour définir l'activité actuelle de l'utilisateur au moyen de l'activation du titre, consultez [Rejoindre une session MPSD à partir d'une activation de titre](#jamsfata) dans cette rubrique.
[Retour en haut de cette rubrique.](#top)
## Mettre à jour une session MPSD
Lorsque votre titre met à jour une session existante à l'aide de l'API multijoueur, n'oubliez pas qu'il travaille sur une copie locale jusqu'à ce qu'il appelle l'écriture de la session.
Pour mettre à jour une session existante, le titre doit procéder comme suit :
1. Apportez les modifications requises à la session actuelle, par exemple en appelant [XblMultiplayerSessionLeave](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessionleave).
2. Une fois toutes les modifications apportées, écrivez les modifications locales dans MPSD à l'aide de l'une de ces méthodes.
* [XblMultiplayerWriteSessionAsync](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayerwritesessionasync)
* [XblMultiplayerWriteSessionByHandleAsync](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayerwritesessionbyhandleasync)
Définissez le mode d'écriture sur [XblMultiplayerSessionWriteMode](/fr-CA/reference/live/xsapi-c/multiplayer_c/enums/xblmultiplayersessionwritemode)`::SynchronizedUpdate` si vous écrivez dans une partie partagée que d'autres titres peuvent également modifier. Pour plus d'informations, consultez la section [Synchronisation des mises à jour de session](/fr-CA/services/xbox-services/multiplayer/mpsd/live-mpsd-overview#synchronization-of-session-updates) de la rubrique Vue d'ensemble de Multiplayer Session Directory.
La méthode d'écriture écrit la jonction sur le serveur et obtient la dernière session, à partir de laquelle découvrir les autres membres de la session et les adresses d'appareil sécurisées (SDA) de leurs consoles. Pour plus d'informations sur l'établissement d'une connexion réseau entre ces consoles, consultez Introduction to Winsock on XBOX One.
3. Supprimez l'ancien objet de session local. Utilisez l'objet de session nouvellement récupéré afin que les actions futures reposent sur le dernier état connu de la session.
[Retour en haut de cette rubrique.](#top)
## Quitter une session MPSD
Pour permettre à un utilisateur de quitter une session, le titre doit procéder comme suit :
1. Appelez [XblMultiplayerSessionLeave](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessionleave) pour la session de jeu.
2. Mettez à jour la session de jeu dans MPSD comme décrit dans la section [Mettre à jour une session MPSD](#update-an-mpsd-session) de cette rubrique.
3. Si nécessaire, appelez la méthode `XblMultiplayerSessionLeave` pour la session de lobby, puis mettez à jour cette session.
4. Si nécessaire pour la session de lobby, arrêtez l'API multijoueur en vous désinscrivant à l'aide d'appels à [XblMultiplayerRemoveSubscriptionLostHandler](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayerremovesubscriptionlosthandler) et à [XblMultiplayerRemoveSessionChangedHandler](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayerremovesessionchangedhandler).
L'organigramme suivant montre comment quitter la session et arrêter le multijoueur.
[Retour en haut de cette rubrique.](#top)
## Remplir les emplacements de session libres pendant le matchmaking
Pour remplir les emplacements libres d'une session de ticket pendant le matchmaking, le titre doit suivre des étapes similaires aux suivantes :
1. Accédez au dernier état de session de la session de ticket créée pendant le matchmaking.
2. Ajoutez les joueurs disponibles pour jouer à partir de la session de lobby.
3. Déterminez si la session de ticket est pleine.
4. Si la session est pleine, poursuivez la partie.
5. Si la session n'est pas encore pleine, créez le ticket de match comme décrit dans [Créer un ticket de match](#camt) dans cette rubrique. Assurez-vous de créer le ticket avec le paramètre `preserveSession` défini sur `Always`.
6. Poursuivez le matchmaking. Pour plus d'informations, consultez [Vue d'ensemble du matchmaking](/fr-CA/services/xbox-services/multiplayer/matchmaking/live-matchmaking-overview).
L'organigramme suivant montre comment remplir les emplacements de session libres pendant le matchmaking.
[Retour en haut de cette rubrique.](#top)
## Créer un ticket de match
Pour créer un ticket de match, l'éclaireur de matchmaking doit procéder comme suit :
1. Appelez [XblMatchmakingCreateMatchTicketAsync](/fr-CA/reference/live/xsapi-c/matchmaking_c/functions/xblmatchmakingcreatematchticketasync) en transmettant une référence à la session de ticket. La méthode lit la session de ticket dans MPSD et démarre le matchmaking pour les utilisateurs de la session. En interne, la méthode appelle `POST (/serviceconfigs/{scid}/hoppers/{hoppername})`.
2. Définissez le paramètre `preserveSession` sur `Never` si le service de matchmaking doit associer les membres de la session dans une nouvelle session ou dans une autre session existante. Définissez le paramètre `preserveSession` sur `Always` pour permettre au titre de réutiliser une session de jeu existante comme session de ticket afin de poursuivre la partie. Le service de matchmaking peut alors garantir que la session soumise est conservée et que les joueurs associés sont ajoutés à cette session.
3. Utilisez [XblCreateMatchTicketResponse](/fr-CA/reference/live/xsapi-c/matchmaking_c/structs/xblcreatematchticketresponse)`::EstimatedWaitTime`, retourné dans l'objet `CreateMatchTicketResponse`, pour informer les utilisateurs de la durée attendue du matchmaking.
4. Utilisez [XblCreateMatchTicketResponse](/fr-CA/reference/live/xsapi-c/matchmaking_c/structs/xblcreatematchticketresponse)`::MatchTicketId`, retourné dans l'objet de réponse, pour annuler le matchmaking de la session si nécessaire, en supprimant le ticket. La suppression du ticket utilise [XblMatchmakingDeleteMatchTicketAsync](/fr-CA/reference/live/xsapi-c/matchmaking_c/functions/xblmatchmakingdeletematchticketasync).
[Retour en haut de cette rubrique.](#top)
## Obtenir l'état d'un ticket de match
Votre titre doit procéder comme suit pour récupérer l'état d'un ticket de match.
1. Obtenez l'objet `XblMultiplayerSessionHandle` de la session de ticket.
2. Appelez [XblMultiplayerSessionMatchmakingServer](/fr-CA/reference/live/xsapi-c/multiplayer_c/functions/xblmultiplayersessionmatchmakingserver) pour accéder à l'objet [XblMultiplayerMatchmakingServer](/fr-CA/reference/live/xsapi-c/multiplayer_c/structs/xblmultiplayermatchmakingserver) utilisé lors du matchmaking.
3. Vérifiez l'objet `XblMultiplayerMatchmakingServer` pour déterminer l'état du processus de matchmaking, le temps d'attente habituel pour la session et la référence de la session cible, si un match a été trouvé.
## Related topics
- [Vue d'ensemble de Multiplayer Session Directory](/fr-CA/services/xbox-services/multiplayer/mpsd/live-mpsd-overview.md)
- [Rubriques avancées sur les sessions multijoueurs](/fr-CA/services/xbox-services/multiplayer/mpsd/concepts/live-mpsd-details.md)
- [Exemple de code Multiplayer Session Directory (MPSD)](/fr-CA/services/xbox-services/multiplayer/mpsd/how-to/live-mpsd-howto-nav.md)
- [FAQ et résolution des problèmes multijoueurs](/fr-CA/services/xbox-services/multiplayer/mpsd/concepts/live-multiplayer-2015-faq.md)
- [Procédures](/fr-CA/services/xbox-services/multiplayer/mpsd/how-to/index.md)