gpg::TurnBasedMultiplayerManager

#include <turn_based_multiplayer_manager.h>

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

Résumé

Types publics
MatchInboxUICallback	typedef std::function< void(const MatchInboxUIResponse &)> Définit un rappel qui peut recevoir un MatchInboxUIResponse de ShowMatchInboxUI.
MultiplayerStatusCallback	typedef std::function< void(MultiplayerStatus)> Définit un rappel qui peut être utilisé pour recevoir un objet MultiplayerStatus.
PlayerSelectUICallback	typedef std::function< void(const PlayerSelectUIResponse &)> Définit un rappel qui peut 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 en tour par tour.
TurnBasedMatchesCallback	typedef std::function< void(const TurnBasedMatchesResponse &)> Définit un rappel qui peut recevoir un TurnBasedMatchesResponse de l'une des opérations multijoueurs en tour par tour.

Attributs statiques publics
kAutomatchingParticipant	const MultiplayerParticipant Un participant qui peut être transmis à des méthodes qui prennent le "prochain participant".

Fonctions publiques
AcceptInvitation(const MultiplayerInvitation & invitation, TurnBasedMatchCallback callback)	void Accepte un MultiplayerInvitation de manière asynchrone et renvoie le résultat via un TurnBasedMatchCallback.
AcceptInvitationBlocking(Timeout timeout, const MultiplayerInvitation & invitation)	TurnBasedMatchResponse Version bloquante de AcceptInvitation.
AcceptInvitationBlocking(const MultiplayerInvitation & invitation)	TurnBasedMatchResponse 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)	MultiplayerStatus Version bloquante de CancelMatch.
CancelMatchBlocking(const TurnBasedMatch & match)	MultiplayerStatus Surcharge d'CancelMatch, qui utilise un délai d'expiration par défaut de 10 ans.
ConfirmPendingCompletion(const TurnBasedMatch & match, TurnBasedMatchCallback callback)	void Confirme les résultats d'une correspondance qui est terminée et qui est en attente de finalisation locale.
ConfirmPendingCompletionBlocking(Timeout timeout, const TurnBasedMatch & match)	TurnBasedMatchResponse Version bloquante de ConfirmPendingCompletion.
ConfirmPendingCompletionBlocking(const TurnBasedMatch & match)	TurnBasedMatchResponse 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)	TurnBasedMatchResponse Version bloquante de CreateTurnBasedMatch.
CreateTurnBasedMatchBlocking(const gpg::TurnBasedMatchConfig & config)	TurnBasedMatchResponse Surcharge de CreateTurnBasedMatchBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
DeclineInvitation(const MultiplayerInvitation & invitation)	void Remplace une MultiplayerInvitation par une TurnBasedMatch.
DismissInvitation(const MultiplayerInvitation & invitation)	void Ignore un MultiplayerInvitation en TurnBasedMatch.
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)	TurnBasedMatchResponse Version bloquante de FetchMatch.
FetchMatchBlocking(const std::string & match_id)	TurnBasedMatchResponse 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 lecteur actuel.
FetchMatchesBlocking(Timeout timeout)	TurnBasedMatchesResponse Blocage de la version de FetchMatches.
FetchMatchesBlocking()	TurnBasedMatchesResponse 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 Termine de manière asynchrone la correspondance spécifiée.
FinishMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)	TurnBasedMatchResponse Version bloquante de FinishMatchDuringMyTurn.
FinishMatchDuringMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results)	TurnBasedMatchResponse 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 une partie de manière asynchrone au tour du participant local.
LeaveMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)	MultiplayerStatus Version bloquante de LeaveMatchDuringMyTurn.
LeaveMatchDuringMyTurnBlocking(const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)	MultiplayerStatus Surcharge de LeaveMatchDuringMyTurnBlocking, qui utilise un délai avant expiration par défaut de 10 ans.
LeaveMatchDuringTheirTurn(const TurnBasedMatch & match, MultiplayerStatusCallback callback)	void Quitte une partie de manière asynchrone au tour d'un autre participant.
LeaveMatchDuringTheirTurnBlocking(Timeout timeout, const TurnBasedMatch & match)	MultiplayerStatus Version bloquante de LeaveMatchDuringTheirTurn.
LeaveMatchDuringTheirTurnBlocking(const TurnBasedMatch & match)	MultiplayerStatus Surcharge de LeaveMatchDuringTheirTurnBlocking avec un délai avant expiration par défaut de 10 ans.
Rematch(const TurnBasedMatch & match, TurnBasedMatchCallback callback)	void Renvoie une partie dont l'état est MatchStatus::COMPLETED.
RematchBlocking(Timeout timeout, const TurnBasedMatch & match)	TurnBasedMatchResponse Version bloquante de Rematch.
RematchBlocking(const TurnBasedMatch & match)	TurnBasedMatchResponse 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 correspondances, ce qui permet au joueur de sélectionner une correspondance ou une invitation.
ShowMatchInboxUIBlocking(Timeout timeout)	MatchInboxUIResponse Version bloquante de ShowMatchInboxUI.
ShowMatchInboxUIBlocking()	MatchInboxUIResponse 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 lui permet de sélectionner d'autres joueurs avec qui jouer.
ShowPlayerSelectUIBlocking(Timeout timeout, uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)	PlayerSelectUIResponse Version bloquante de ShowPlayerSelectUI
ShowPlayerSelectUIBlocking(uint32_t minimum_players, uint32_t maximum_players, bool allow_automatch)	PlayerSelectUIResponse 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 TBMP avec le serveur.
TakeMyTurn(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant, TurnBasedMatchCallback callback)	void De manière asynchrone, cela prend le tour du participant local.
TakeMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)	TurnBasedMatchResponse Blocage de la version de TakeMyTurn
TakeMyTurnBlocking(const TurnBasedMatch & match, std::vector< uint8_t > match_data, const ParticipantResults & results, const MultiplayerParticipant & next_participant)	TurnBasedMatchResponse 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 qui peut recevoir un MatchInboxUIResponse de ShowMatchInboxUI.

MultiplayerStatusCallback

std::function< void(MultiplayerStatus)> MultiplayerStatusCallback

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

Utilisé par les fonctions ManyMatch etCancelMatch.

PlayerSelectUICallback

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

Définit un rappel qui peut 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 en tour par tour.

TurnBasedMatchesCallback

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

Définit un rappel qui peut recevoir un TurnBasedMatchesResponse de l'une des opérations multijoueurs en tour par tour.

Attributs statiques publics

kAutomatchingParticipant

const MultiplayerParticipant kAutomatchingParticipant

Un participant qui peut être transmis à des méthodes qui prennent le "prochain participant".

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

Fonctions publiques

AcceptInvitation

void AcceptInvitation(
  const MultiplayerInvitation & invitation,
  TurnBasedMatchCallback callback
)

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

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

AcceptInvitationBlocking

TurnBasedMatchResponse AcceptInvitationBlocking(
  Timeout timeout,
  const MultiplayerInvitation & invitation
)

Version bloquante de 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é via MultiplayerStatusCallback indique si l'opération a réussi. Pour que cette fonction soit utilisable, l'état de correspondance doit être INVITATIOND, THEIR_turn ou MY_turn.

CancelMatchBlocking

MultiplayerStatus CancelMatchBlocking(
  Timeout timeout,
  const TurnBasedMatch & match
)

Version bloquante 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 d'CancelMatch, qui utilise un délai d'expiration par défaut de 10 ans.

ConfirmPendingCompletion

void ConfirmPendingCompletion(
  const TurnBasedMatch & match,
  TurnBasedMatchCallback callback
)

Confirme les résultats d'une correspondance qui est terminée et qui est 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 Correspondance dont l'achèvement doit être confirmé. callback Rappel recevant un TurnBasedMatchResponse.

ConfirmPendingCompletionBlocking

TurnBasedMatchResponse ConfirmPendingCompletionBlocking(
  Timeout timeout,
  const TurnBasedMatch & match
)

Version bloquante 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 le TurnBasedMatchCallback fourni. Un TurnBasedMatch nouvellement créé démarre toujours à l'état TurnBasedMatchState::MY_TURN.

CreateTurnBasedMatchBlocking

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

Version bloquante 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
)

Remplace une MultiplayerInvitation par une TurnBasedMatch.

Cette action annule la partie pour les autres participants et la supprime de l'appareil du joueur local.

DismissInvitation

void DismissInvitation(
  const MultiplayerInvitation & invitation
)

Ignore un MultiplayerInvitation en TurnBasedMatch.

Cela ne modifie pas l'état visible de l'TurnBasedMatch pour les autres participants, mais supprime le 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 l'TurnBasedMatch pour les autres participants, mais supprime le 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 TurnBasedMatchCallback.

FetchMatchBlocking

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

Version bloquante 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 lecteur actuel.

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

FetchMatchesBlocking

TurnBasedMatchesResponse FetchMatchesBlocking(
  Timeout timeout
)

Blocage de la version 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
)

Termine de manière asynchrone la correspondance spécifiée.

Vous pouvez l'utiliser à la place de TakeMyTurn lors du dernier tour de match. 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 le TurnBasedMatchCallback. fourni. Cette fonction ne peut être appelée que lorsque TurnBasedMatch::Status() renvoie MatchStatus::MY_TURN..

Détails

Paramètres

match La partie est terminée. match_data Blob de données représentant l'état final de la correspondance. results Tous les résultats pour chaque joueur du match. Notez que ces résultats ne doivent pas contredire les résultats spécifiés précédemment via TakeTurn. Si vous tentez de définir des résultats différents pour un joueur, cela entraîne l'erreur 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
)

Version bloquante 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 une partie de manière asynchrone au tour du participant local.

La réponse renvoyée via TurnBasedMatchCallback contient l'état de la partie une fois que le joueur local est parti. Si moins de deux participants sont présents dans la partie, celle-ci est annulée. match.Status() doit renvoyer MatchStatus::MY_TURN pour que cette fonction soit utilisable.

Détails
Paramètres	match C'est parti. next_participant Le participant dont le tour est le suivant TurnBasedMultiplayerManager::kAutomatchingParticipant permet d'indiquer que le participant suivant doit être sélectionné via la mise en correspondance automatique. callback Le rappel qui reçoit le TurnBasedMatchResponse

LeaveMatchDuringMyTurnBlocking

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

Version bloquante 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 une partie de manière asynchrone au tour d'un autre participant.

La réponse renvoyée via MultiplayerStatusCallback indique si le participant local a quitté la partie avec succès. Si moins de deux participants sont présents dans la partie, celle-ci est annulée. match.Status() doit renvoyer MatchStatus::THEIR_TURN pour que cette fonction soit utilisable.

LeaveMatchDuringTheirTurnBlocking

MultiplayerStatus LeaveMatchDuringTheirTurnBlocking(
  Timeout timeout,
  const TurnBasedMatch & match
)

Version bloquante 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 avec un délai avant expiration par défaut de 10 ans.

Revanche

void Rematch(
  const TurnBasedMatch & match,
  TurnBasedMatchCallback callback
)

Renvoie une partie dont l'état est MatchStatus::COMPLETED.

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

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

RematchBlocking

TurnBasedMatchResponse RematchBlocking(
  Timeout timeout,
  const TurnBasedMatch & match
)

Version bloquante 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 correspondances, ce qui permet au joueur de sélectionner une correspondance 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
)

Version bloquante 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 lui permet de sélectionner d'autres joueurs avec qui jouer.

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

ShowPlayerSelectUIBlocking

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

Version bloquante 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 TBMP 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
)

De manière asynchrone, cela prend le tour du participant local.

Lorsqu'il prend son tour, le participant peut spécifier une nouvelle valeur pour match_data, ainsi qu'un ensemble de ParticipantResults. Lorsque le tour est terminé, 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 Le match où a lieu le tour. match_data Blob de données à envoyer au participant suivant. results Tous les résultats connus pour le match à l'heure actuelle. Notez que le résultat pour un joueur donné ne peut être spécifié qu'une seule fois. Si vous tentez de définir des résultats différents pour un joueur, cela entraîne l'erreur ERROR_INVALID_RESULTS. next_participant Le participant dont le tour est le suivant TurnBasedMultiplayerManager::kAutomatchingParticipant permet d'indiquer 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.