gpg:: TurnBasedMultiplayerManager
#include <turn_based_multiplayer_manager.h>
Récupère, modifie et crée des objets TurnBasedMatch
.
Résumé
Types publics |
|
---|---|
MatchInboxUICallback
|
typedefstd::function< void(const MatchInboxUIResponse &)>
Définit un rappel qui peut recevoir un MatchInboxUIResponse de ShowMatchInboxUI . |
MultiplayerStatusCallback
|
typedefstd::function< void(MultiplayerStatus)>
Définit un rappel qui peut être utilisé pour recevoir un objet MultiplayerStatus. |
PlayerSelectUICallback
|
typedefstd::function< void(const PlayerSelectUIResponse &)>
Définit un rappel qui peut recevoir un PlayerSelectUIResponse de ShowPlayerSelectUI . |
TurnBasedMatchCallback
|
typedefstd::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
|
typedefstd::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)
|
Version bloquante de 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)
|
Version bloquante de CancelMatch.
|
CancelMatchBlocking(const TurnBasedMatch & match)
|
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)
|
Version bloquante 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)
|
Version bloquante 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
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)
|
Version bloquante 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 lecteur actuel. |
FetchMatchesBlocking(Timeout timeout)
|
Blocage de la version 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
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)
|
Version bloquante 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 une partie de manière asynchrone au tour du participant local.
|
LeaveMatchDuringMyTurnBlocking(Timeout timeout, const TurnBasedMatch & match, const MultiplayerParticipant & next_participant)
|
Version bloquante 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 une partie de manière asynchrone au tour d'un autre participant.
|
LeaveMatchDuringTheirTurnBlocking(Timeout timeout, const TurnBasedMatch & match)
|
Version bloquante de LeaveMatchDuringTheirTurn.
|
LeaveMatchDuringTheirTurnBlocking(const TurnBasedMatch & match)
|
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)
|
Version bloquante 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 correspondances, ce qui permet au joueur de sélectionner une correspondance ou une invitation.
|
ShowMatchInboxUIBlocking(Timeout timeout)
|
Version bloquante 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 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)
|
Version bloquante 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 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)
|
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:: |
|
gpg:: |
|
gpg:: |
|
gpg:: |
|
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 |
|
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 |
|
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 |
|
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 |
|
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 |
|
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.