gpg::TurnBasedMultiplayerManager

#include <turn_based_multiplayer_manager.h>

Récupère, modifie et crée les objets TurnBasedMatch.

Résumé

Types publics
MatchInboxUICallback typedef
std::function< void(const MatchInboxUIResponse &)>
Définit un rappel pouvant recevoir un MatchInboxUIResponse de ShowMatchInboxUI.
MultiplayerStatusCallback typedef
std::function< void(MultiplayerStatus)>
Définit un rappel qui peut être utilisé pour recevoir un MultiplayerStatus.
PlayerSelectUICallback typedef
std::function< void(const PlayerSelectUIResponse &)>
Définit un rappel pouvant recevoir un PlayerSelectUIResponse de ShowPlayerSelectUI.
TurnBasedMatchCallback typedef
std::function< void(const TurnBasedMatchResponse &)>
Définit un rappel qui peut être utilisé pour recevoir un TurnBasedMatchResponse de l'une des opérations multijoueurs au tour par tour.
TurnBasedMatchesCallback typedef
std::function< void(const TurnBasedMatchesResponse &)>
Définit un rappel pouvant recevoir un TurnBasedMatchesResponse de l'une des opérations multijoueurs au tour par tour.

Attributs statiques publics
kAutomatchingParticipant
Participant pouvant être transmis à des méthodes qui prennent une "prochaine" participant.

Fonctions publiques
AcceptInvitation(const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback)
void
Accepte de manière asynchrone un MultiplayerInvitation et renvoie le résultat via une TurnBasedMatchCallback.
AcceptInvitationBlocking(Timeout timeout, const MultiplayerInvitation & invitation)
Blocage de la version d'AcceptInvitation.
AcceptInvitationBlocking(const MultiplayerInvitation & invitation)
Surcharge de AcceptInvitationBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
CancelMatch(const TurnBasedMatch & match, MultiplayerStatusCallback callback)
void
Annule une correspondance de manière asynchrone.
CancelMatchBlocking(Timeout timeout, const TurnBasedMatch & match)
Blocage de la version de CancelMatch.
CancelMatchBlocking(const TurnBasedMatch & match)
Surcharge de CancelMatch, qui utilise un délai avant expiration par défaut de 10 ans.
ConfirmPendingCompletion(const TurnBasedMatch & match, TurnBasedMatchCallback callback)
void
Confirme les résultats d'une correspondance terminée et en attente de finalisation locale.
ConfirmPendingCompletionBlocking(Timeout timeout, const TurnBasedMatch & match)
Blocage de la version de ConfirmPendingCompletion.
ConfirmPendingCompletionBlocking(const TurnBasedMatch & match)
Surcharge de ConfirmPendingCompletionBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
CreateTurnBasedMatch(const gpg::TurnBasedMatchConfig & config, TurnBasedMatchCallback callback)
void
Crée un TurnBasedMatch de manière asynchrone à l'aide du TurnBasedMatchConfig fourni.
CreateTurnBasedMatchBlocking(Timeout timeout, const gpg::TurnBasedMatchConfig & config)
Blocage de la version de CreateTurnBasedMatch.
CreateTurnBasedMatchBlocking(const gpg::TurnBasedMatchConfig & config)
Surcharge de CreateTurnBasedMatchBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
DeclineInvitation(const MultiplayerInvitation & invitation)
void
DismissInvitation(const MultiplayerInvitation & invitation)
void
DismissMatch(const TurnBasedMatch & match)
void
Ignore un élément TurnBasedMatch.
FetchMatch(const std::string & match_id, TurnBasedMatchCallback callback)
void
Récupère de manière asynchrone une correspondance spécifique par ID.
FetchMatchBlocking(Timeout timeout, const std::string & match_id)
Blocage de la version de FetchMatch.
FetchMatchBlocking(const std::string & match_id)
Surcharge de FetchMatchBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
FetchMatches(TurnBasedMatchesCallback callback)
void
Récupère de manière asynchrone les objets TurnBasedMatch et Invitation pour le joueur actif.
FetchMatchesBlocking(Timeout timeout)
Version bloquante de FetchMatches.
FetchMatchesBlocking()
Surcharge de FetchMatchesBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
FinishMatchDuringMyTurn(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, TurnBasedMatchCallback callback)
void
Met fin à la correspondance spécifiée de manière asynchrone.
FinishMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)
Blocage de la version de FinishMatchDuringMyTurn
FinishMatchDuringMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)
Surcharge de FinishMatchDuringMyTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
LeaveMatchDuringMyTurn(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant, MultiplayerStatusCallback callback)
void
Quitte de manière asynchrone une partie pendant le tour du participant local.
LeaveMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
Blocage de la version de LeaveMatchDuringMyTurn.
LeaveMatchDuringMyTurnBlocking(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
Surcharge de LeaveMatchDuringMyTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
LeaveMatchDuringTheirTurn(const TurnBasedMatch & match, MultiplayerStatusCallback callback)
void
Quitte de manière asynchrone une partie au tour d'un autre participant.
LeaveMatchDuringTheirTurnBlocking(Timeout timeout, const TurnBasedMatch & match)
Blocage de la version de LeaveMatchDuringTheirTurn
LeaveMatchDuringTheirTurnBlocking(const TurnBasedMatch & match)
Surcharge de LeaveMatchDuringTheirTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
Rematch(const TurnBasedMatch & match, TurnBasedMatchCallback callback)
void
Remplace une correspondance dont l'état est MatchStatus::COMPLETED.
RematchBlocking(Timeout timeout, const TurnBasedMatch & match)
Blocage de la version de Rematch
RematchBlocking(const TurnBasedMatch & match)
Surcharge de RematchBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
ShowMatchInboxUI(MatchInboxUICallback callback)
void
Affiche de manière asynchrone l'interface utilisateur de la boîte de réception des matchs, ce qui permet au joueur de sélectionner une partie ou une invitation.
ShowMatchInboxUIBlocking(Timeout timeout)
Blocage de la version de ShowMatchInboxUI
ShowMatchInboxUIBlocking()
Surcharge de ShowMatchInboxUIBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
ShowPlayerSelectUI(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch, PlayerSelectUICallback callback)
void
Affiche de manière asynchrone l'interface utilisateur de sélection du joueur, ce qui permet au joueur de sélectionner d'autres joueurs avec lesquels jouer une partie.
ShowPlayerSelectUIBlocking(Timeout timeout, uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)
Blocage de la version de ShowPlayerSelectUI.
ShowPlayerSelectUIBlocking(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)
Surcharge de ShowPlayerSelectUIBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
SynchronizeData()
void
Force la synchronisation des données de correspondance TOMP avec le serveur.
TakeMyTurn(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant, TurnBasedMatchCallback callback)
void
Elle prend le tour du participant local de manière asynchrone.
TakeMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)
Blocage de la version de TakeMyTurn
TakeMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)
Surcharge de TakeMyTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans

Structs
gpg::TurnBasedMultiplayerManager::MatchInboxUIResponse

Data et ResponseStatus pour l'opération ShowMatchInboxUI.

gpg::TurnBasedMultiplayerManager::PlayerSelectUIResponse

Data et ResponseStatus pour l'opération ShowPlayerSelectUI.

gpg::TurnBasedMultiplayerManager::TurnBasedMatchResponse

Data et ResponseStatus pour un TurnBasedMatch spécifique.

gpg::TurnBasedMultiplayerManager::TurnBasedMatchesResponse

Data et ResponseStatus pour les TurnBasedMatches et les invitations.

Types publics

MatchInboxUICallback

std::function< void(const MatchInboxUIResponse &)> MatchInboxUICallback

Définit un rappel pouvant recevoir un MatchInboxUIResponse de ShowMatchInboxUI.

MultiplayerStatusCallback

std::function< void(MultiplayerStatus)> MultiplayerStatusCallback

Définit un rappel qui peut être utilisé pour recevoir un MultiplayerStatus.

Utilisé par les fonctions Part de la correspondance et Annulation de la correspondance.

PlayerSelectUICallback

std::function< void(const PlayerSelectUIResponse &)> PlayerSelectUICallback

Définit un rappel pouvant recevoir un PlayerSelectUIResponse de ShowPlayerSelectUI.

TurnBasedMatchCallback

std::function< void(const TurnBasedMatchResponse &)> TurnBasedMatchCallback

Définit un rappel qui peut être utilisé pour recevoir un TurnBasedMatchResponse de l'une des opérations multijoueurs au tour par tour.

TurnBasedMatchesCallback

std::function< void(const TurnBasedMatchesResponse &)> TurnBasedMatchesCallback

Définit un rappel pouvant recevoir un TurnBasedMatchesResponse de l'une des opérations multijoueurs au tour par tour.

Attributs statiques publics

kAutomatchingParticipant

const MultiplayerParticipant kAutomatchingParticipant

Participant pouvant être transmis à des méthodes qui prennent une "prochaine" participant.

La méthode sélectionne alors le participant suivant via la mise en correspondance automatique. La transmission de kAutomatchingParticipant à une fonction n'est valide que si la valeur TurnBasedMatch::AutomatchingSlotsAvailable est supérieure à 0 pour la correspondance associée.

Fonctions publiques

AcceptInvitation

void AcceptInvitation(
  const MultiplayerInvitation & invitation,
  TurnBasedMatchCallback callback
)

Accepte de manière asynchrone un MultiplayerInvitation et renvoie le résultat via une TurnBasedMatchCallback.

Si l'opération aboutit, le TurnBasedMatch renvoyé par le rappel est à l'état TurnBasedMatchState::MY_TURN.

AcceptInvitationBlocking

TurnBasedMatchResponse AcceptInvitationBlocking(
  Timeout timeout,
  const MultiplayerInvitation & invitation
)

Blocage de la version d'AcceptInvitation.

Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT.

AcceptInvitationBlocking

TurnBasedMatchResponse AcceptInvitationBlocking(
  const MultiplayerInvitation & invitation
)

Surcharge de AcceptInvitationBlocking, qui utilise un délai avant expiration par défaut de 10 ans.

CancelMatch

void CancelMatch(
  const TurnBasedMatch & match,
  MultiplayerStatusCallback callback
)

Annule une correspondance de manière asynchrone.

L'état renvoyé par MultiplayerStatusCallback indique si l'opération a réussi. L'état de la mise en correspondance doit être guestD, THEIR_TURN ou MY_TURN pour que cette fonction soit utilisable.

CancelMatchBlocking

MultiplayerStatus CancelMatchBlocking(
  Timeout timeout,
  const TurnBasedMatch & match
)

Blocage de la version de CancelMatch.

Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT.

CancelMatchBlocking

MultiplayerStatus CancelMatchBlocking(
  const TurnBasedMatch & match
)

Surcharge de CancelMatch, qui utilise un délai avant expiration par défaut de 10 ans.

ConfirmPendingCompletion

void ConfirmPendingCompletion(
  const TurnBasedMatch & match,
  TurnBasedMatchCallback callback
)

Confirme les résultats d'une correspondance terminée et en attente de finalisation locale.

Cette fonction ne peut être appelée que lorsque TurnBasedMatch::Status() renvoie MatchStatus::PENDING_COMPLETION.

Détails
Paramètres
match
La partie dont l'achèvement doit être confirmé.
callback
Rappel recevant un TurnBasedMatchResponse

ConfirmPendingCompletionBlocking

TurnBasedMatchResponse ConfirmPendingCompletionBlocking(
  Timeout timeout,
  const TurnBasedMatch & match
)

Blocage de la version de ConfirmPendingCompletion.

Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT.

ConfirmPendingCompletionBlocking

TurnBasedMatchResponse ConfirmPendingCompletionBlocking(
  const TurnBasedMatch & match
)

Surcharge de ConfirmPendingCompletionBlocking, qui utilise un délai avant expiration par défaut de 10 ans.

CreateTurnBasedMatch

void CreateTurnBasedMatch(
  const gpg::TurnBasedMatchConfig & config,
  TurnBasedMatchCallback callback
)

Crée un TurnBasedMatch de manière asynchrone à l'aide du TurnBasedMatchConfig fourni.

Si la création aboutit, cette fonction renvoie TurnBasedMatch via la TurnBasedMatchCallback fournie. Une nouvelle TurnBasedMatch commence toujours à l'état TurnBasedMatchState::MY_TURN.

CreateTurnBasedMatchBlocking

TurnBasedMatchResponse CreateTurnBasedMatchBlocking(
  Timeout timeout,
  const gpg::TurnBasedMatchConfig & config
)

Blocage de la version de CreateTurnBasedMatch.

Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT.

CreateTurnBasedMatchBlocking

TurnBasedMatchResponse CreateTurnBasedMatchBlocking(
  const gpg::TurnBasedMatchConfig & config
)

Surcharge de CreateTurnBasedMatchBlocking, qui utilise un délai avant expiration par défaut de 10 ans.

DeclineInvitation

void DeclineInvitation(
  const MultiplayerInvitation & invitation
)

Refuse un MultiplayerInvitation en TurnBasedMatch.

Cela annule la partie des autres participants et la supprime de l'appareil du joueur local.

DismissInvitation

void DismissInvitation(
  const MultiplayerInvitation & invitation
)

Ignore une MultiplayerInvitation en TurnBasedMatch.

Cela ne modifie pas l'état visible de TurnBasedMatch pour les autres participants, mais supprime TurnBasedMatch de l'appareil du joueur local.

DismissMatch

void DismissMatch(
  const TurnBasedMatch & match
)

Ignore un élément TurnBasedMatch.

Cela ne modifie pas l'état visible de TurnBasedMatch pour les autres participants, mais supprime TurnBasedMatch de l'appareil du joueur local.

FetchMatch

void FetchMatch(
  const std::string & match_id,
  TurnBasedMatchCallback callback
)

Récupère de manière asynchrone une correspondance spécifique par ID.

Le résultat de cette opération est renvoyé via un TurnBasedMatchCallback.

FetchMatchBlocking

TurnBasedMatchResponse FetchMatchBlocking(
  Timeout timeout,
  const std::string & match_id
)

Blocage de la version de FetchMatch.

Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT.

FetchMatchBlocking

TurnBasedMatchResponse FetchMatchBlocking(
  const std::string & match_id
)

Surcharge de FetchMatchBlocking, qui utilise un délai avant expiration par défaut de 10 ans.

FetchMatches

void FetchMatches(
  TurnBasedMatchesCallback callback
)

Récupère de manière asynchrone les objets TurnBasedMatch et Invitation pour le joueur actif.

Toutes les correspondances actives et jusqu'à 10 correspondances terminées sont renvoyées.

FetchMatchesBlocking

TurnBasedMatchesResponse FetchMatchesBlocking(
  Timeout timeout
)

Version bloquante de FetchMatches.

Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT.

FetchMatchesBlocking

TurnBasedMatchesResponse FetchMatchesBlocking()

Surcharge de FetchMatchesBlocking, qui utilise un délai avant expiration par défaut de 10 ans.

FinishMatchDuringMyTurn

void FinishMatchDuringMyTurn(
  const TurnBasedMatch & match,
  std::vector< uint8_t > match_data,
  const ParticipantResults & results,
  TurnBasedMatchCallback callback
)

Met fin à la correspondance spécifiée de manière asynchrone.

Peut être utilisé à la place de TakeMyTurn pendant le dernier tour de la partie. Permet à l'appelant de spécifier une valeur finale pour match_data, ainsi qu'un ensemble de valeurs finales pour ParticipantResults. Une fois cette opération terminée, la correspondance mise à jour est renvoyée via la TurnBasedMatchCallback. fournie. Cette fonction ne peut être appelée que lorsque TurnBasedMatch::Status() renvoie MatchStatus::MY_TURN..

Détails
Paramètres
match
Le match est terminé.
match_data
Blob de données représentant l'état final de la correspondance.
results
Tous les résultats pour chaque joueur dans le match. Notez que ces résultats ne doivent pas contredire les résultats spécifiés précédemment via TakeTurn. Tenter de définir des résultats différents pour un joueur génère ERROR_INVALID_RESULTS.
callback
Rappel qui reçoit le TurnBasedMatchResponse.

FinishMatchDuringMyTurnBlocking

TurnBasedMatchResponse FinishMatchDuringMyTurnBlocking(
  Timeout timeout,
  const TurnBasedMatch & match,
  std::vector< uint8_t > match_data,
  const ParticipantResults & results
)

Blocage de la version de FinishMatchDuringMyTurn

Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT.

FinishMatchDuringMyTurnBlocking

TurnBasedMatchResponse FinishMatchDuringMyTurnBlocking(
  const TurnBasedMatch & match,
  std::vector< uint8_t > match_data,
  const ParticipantResults & results
)

Surcharge de FinishMatchDuringMyTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans.

LeaveMatchDuringMyTurn

void LeaveMatchDuringMyTurn(
  const TurnBasedMatch & match,
  const MultiplayerParticipant & next_participant,
  MultiplayerStatusCallback callback
)

Quitte de manière asynchrone une partie pendant le tour du participant local.

La réponse renvoyée via TurnBasedMatchCallback contient l'état de la partie une fois que le joueur local a quitté le jeu. Si le match quitte le match avec moins de deux participants, le match est annulé. match.Status() doit renvoyer MatchStatus::MY_TURN pour que cette fonction soit utilisable.

Détails
Paramètres
match
Le match à partir.
next_participant
Participant dont le tour est le suivant TurnBasedMultiplayerManager::kAutomatchingParticipant permet de spécifier que le participant suivant doit être sélectionné via la mise en correspondance automatique.
callback
Rappel qui reçoit le TurnBasedMatchResponse

LeaveMatchDuringMyTurnBlocking

MultiplayerStatus LeaveMatchDuringMyTurnBlocking(
  Timeout timeout,
  const TurnBasedMatch & match,
  const MultiplayerParticipant & next_participant
)

Blocage de la version de LeaveMatchDuringMyTurn.

Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT.

LeaveMatchDuringMyTurnBlocking

MultiplayerStatus LeaveMatchDuringMyTurnBlocking(
  const TurnBasedMatch & match,
  const MultiplayerParticipant & next_participant
)

Surcharge de LeaveMatchDuringMyTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans.

LeaveMatchDuringTheirTurn

void LeaveMatchDuringTheirTurn(
  const TurnBasedMatch & match,
  MultiplayerStatusCallback callback
)

Quitte de manière asynchrone une partie au tour d'un autre participant.

La réponse renvoyée via MultiplayerStatusCallback indique si le participant local a bien quitté la correspondance. Si le match quitte le match avec moins de deux participants, le match est annulé. match.Status() doit renvoyer MatchStatus::THEIR_TURN pour que cette fonction soit utilisable.

LeaveMatchDuringTheirTurnBlocking

MultiplayerStatus LeaveMatchDuringTheirTurnBlocking(
  Timeout timeout,
  const TurnBasedMatch & match
)

Blocage de la version de LeaveMatchDuringTheirTurn.

Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT.

LeaveMatchDuringTheirTurnBlocking

MultiplayerStatus LeaveMatchDuringTheirTurnBlocking(
  const TurnBasedMatch & match
)

Surcharge de LeaveMatchDuringTheirTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans.

Revanche

void Rematch(
  const TurnBasedMatch & match,
  TurnBasedMatchCallback callback
)

Remplace une correspondance dont l'état est MatchStatus::COMPLETED.

Si la revanche est possible, TurnBasedMatchCallback reçoit la nouvelle correspondance.

Détails
Paramètres
match
Le match à refaire.
callback
Rappel qui reçoit une TurnBasedMatchResponse.

RematchBlocking

TurnBasedMatchResponse RematchBlocking(
  Timeout timeout,
  const TurnBasedMatch & match
)

Blocage de la version de Rematch

Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT.

RematchBlocking

TurnBasedMatchResponse RematchBlocking(
  const TurnBasedMatch & match
)

Surcharge de RematchBlocking, qui utilise un délai avant expiration par défaut de 10 ans.

ShowMatchInboxUI

void ShowMatchInboxUI(
  MatchInboxUICallback callback
)

Affiche de manière asynchrone l'interface utilisateur de la boîte de réception des matchs, ce qui permet au joueur de sélectionner une partie ou une invitation.

Une fois l'opération terminée, la correspondance ou l'invitation sélectionnée est renvoyée via MatchInboxUICallback.

ShowMatchInboxUIBlocking

MatchInboxUIResponse ShowMatchInboxUIBlocking(
  Timeout timeout
)

Blocage de la version de ShowMatchInboxUI

Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT.

ShowMatchInboxUIBlocking

MatchInboxUIResponse ShowMatchInboxUIBlocking()

Surcharge de ShowMatchInboxUIBlocking, qui utilise un délai avant expiration par défaut de 10 ans.

ShowPlayerSelectUI

void ShowPlayerSelectUI(
  uint32_t minimum_players,
  uint32_t maximum_players,
  bool allow_automatch,
  PlayerSelectUICallback callback
)

Affiche de manière asynchrone l'interface utilisateur de sélection du joueur, ce qui permet au joueur de sélectionner d'autres joueurs avec lesquels jouer une partie.

Une fois l'opération terminée, les joueurs sélectionnés seront renvoyés via le PlayerSelectUICallback.

ShowPlayerSelectUIBlocking

PlayerSelectUIResponse ShowPlayerSelectUIBlocking(
  Timeout timeout,
  uint32_t minimum_players,
  uint32_t maximum_players,
  bool allow_automatch
)

Blocage de la version de ShowPlayerSelectUI.

Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT.

ShowPlayerSelectUIBlocking

PlayerSelectUIResponse ShowPlayerSelectUIBlocking(
  uint32_t minimum_players,
  uint32_t maximum_players,
  bool allow_automatch
)

Surcharge de ShowPlayerSelectUIBlocking, qui utilise un délai avant expiration par défaut de 10 ans.

SynchronizeData

void SynchronizeData()

Force la synchronisation des données de correspondance TOMP avec le serveur.

La réception de nouvelles données déclenche une OnTurnBasedMatchEventCallback ou une OnMultiplayerInvitationReceivedCallback.

TakeMyTurn

void TakeMyTurn(
  const TurnBasedMatch & match,
  std::vector< uint8_t > match_data,
  const ParticipantResults & results,
  const MultiplayerParticipant & next_participant,
  TurnBasedMatchCallback callback
)

Elle prend le tour du participant local de manière asynchrone.

Lorsqu'il joue à son tour, le participant peut spécifier une nouvelle valeur pour l'attribut match_data, ainsi qu'un ensemble de valeurs ParticipantResults. Lorsque la partie est terminée, la correspondance mise à jour est renvoyée via TurnBasedMatchCallback. Cette fonction ne peut être appelée que lorsque TurnBasedMatch::Status() est défini sur MatchStatus::MY_TURN.

Détails
Paramètres
match
Match où le tour a lieu.
match_data
Blob de données à envoyer au participant suivant.
results
Tous les résultats connus pour la correspondance à l'heure actuelle. Notez que le résultat pour un joueur donné ne peut être spécifié qu'une seule fois. Tenter de définir des résultats différents pour un joueur génère ERROR_INVALID_RESULTS.
next_participant
Participant dont le tour est le suivant TurnBasedMultiplayerManager::kAutomatchingParticipant permet de spécifier que le participant suivant doit être sélectionné via la mise en correspondance automatique.
callback
Rappel qui reçoit le TurnBasedMatchResponse.

TakeMyTurnBlocking

TurnBasedMatchResponse TakeMyTurnBlocking(
  Timeout timeout,
  const TurnBasedMatch & match,
  std::vector< uint8_t > match_data,
  const ParticipantResults & results,
  const MultiplayerParticipant & next_participant
)

Blocage de la version de TakeMyTurn

Permet à l'appelant de spécifier un délai avant expiration en millisecondes. Une fois le délai spécifié écoulé, la fonction renvoie ERROR_TIMEOUT.

TakeMyTurnBlocking

TurnBasedMatchResponse TakeMyTurnBlocking(
  const TurnBasedMatch & match,
  std::vector< uint8_t > match_data,
  const ParticipantResults & results,
  const MultiplayerParticipant & next_participant
)

Surcharge de TakeMyTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans